Release v1

.dockerignore

@@ -0,0 +1,9 @@
+**/__pycache__
+**/*.py[cod]
+**/.pytest_cache
+**/.cache
+.git
+.env
+.env.*
+base
+model

.gitattributes

@@ -0,0 +1,39 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/examples/visual-coordinates.png filter=lfs diff=lfs merge=lfs -text
+assets/examples/bounding-box.png filter=lfs diff=lfs merge=lfs -text
+demo/assets/person.jpg filter=lfs diff=lfs merge=lfs -text
+model/tokenizer.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.cache/
+.env
+.env.*
+base/

API.md

@@ -0,0 +1,118 @@
+# GPC-1 API
+
+The NVIDIA server exposes `GET /v1/models` and `POST /v1/chat/completions`. Requests use OpenAI-style `messages` and `response_format`; responses contain `choices` and a `gpc1` result object. This is a structured-prediction interface, not a complete Chat Completions implementation.
+
+## Requests and responses
+
+Use `model: "gpc-1"` and a strict JSON schema:
+
+```json
+{"type":"json_schema","json_schema":{"name":"result","strict":true,"schema":{}}}
+```
+
+Replace `schema` with an explicit object schema. Require every property and set `additionalProperties: false`. Supported types are `object`, `array`, `string`, `number`, `integer`, `boolean`, and `null`. References, unions, recursion, and patterns are unsupported.
+
+Put mode-specific options in `gpc1`. OpenAI Python clients can pass them through `extra_body={"gpc1": ...}`.
+
+- `choices[0].message.content`: JSON-encoded selected values.
+- `gpc1`: probability distributions, numeric summaries, and execution accounting.
+- `usage`: `null`; token usage is not reported.
+- Errors: `{"error":{"message": "...", "type": "...", "param": null, "code": "..."}}`.
+
+## Interpreting scores
+
+Probabilities describe the model's distribution over the choices, numeric grid, or complete records supplied in the request. Changing that output space can change the scores. A probability of 0.9 is not a measured 90% accuracy rate; choose decision thresholds using representative examples from your application.
+
+## Atomic categorical
+
+Set `mode: "atomic"`, `field_key`, and an ordered `choices` array of 2–255 unique JSON values. The schema must contain exactly that field with a matching `enum`.
+
+The response includes `value`, `selected_index`, and `probabilities` in choice order.
+
+[Complete categorical request](examples/atomic_request.json)
+
+## Numeric101
+
+Set `mode: "numeric101"` and `numeric_fields`. Each field requires `key`, `description`, `minimum`, `maximum`, and `unit`. Optional `aliases` and `reference` clarify meaning. Schema properties must use `type: "number"` with matching bounds.
+
+Each field uses `value(i) = minimum + (maximum - minimum) × i / 100`, for `i = 0…100`.
+
+| Response field | Meaning |
+| --- | --- |
+| `choices[0].message.content` | Most likely grid value for each key |
+| `gpc1.fields[key].map_value` | Most likely grid value |
+| `gpc1.fields[key].expected_value` | Probability-weighted mean in the declared units |
+| `gpc1.fields[key].probabilities` | Probabilities in ascending grid order |
+| `gpc1.fields[key].normalized_grid` | Grid positions from 0 to 1 |
+
+The mean may fall between grid positions. Numeric fields are separate marginals, not a full joint distribution.
+
+[Complete numeric request](examples/numeric_request.json)
+
+## Finite joint
+
+Set `mode: "finite_joint"` and `allowed_records` containing unique complete JSON records that satisfy the schema. The response includes the selected `value`, candidate `probabilities`, and `log_scores`.
+
+The schema accepts 2–255 records, subject to stricter runtime memory and row limits. The default runtime limit is 32 records. Probabilities are conditional on the supplied records; this mode does not generate arbitrary JSON.
+
+## Images
+
+Include one `image_url` content part containing a base64 PNG, JPEG, or WebP data URI:
+
+```json
+{"type":"image_url","image_url":{"url":"data:image/jpeg;base64,..."}}
+```
+
+Images are supported only in `numeric101`. HTTP(S) and file URLs are rejected. Describe the target, coordinate origin, axes, and units explicitly. For boxes, request `x_min`, `y_min`, `x_max`, and `y_max`; multiply normalized horizontal values by image width and vertical values by image height. Check coordinate ordering before drawing.
+
+The visual README examples use `expected_value`, not the MAP values in message content.
+
+## Deployment
+
+Set `GPC1_MODEL_PATH` to the packaged `model/` directory and `GPC1_API_KEY` to a secret. Send `Authorization: Bearer YOUR_KEY` to the model endpoints. Startup verifies the packaged base and adapter; serving does not fetch models or images from URLs.
+
+Run one server worker per model on a GPU. Model requests execute one at a time; additional requests wait in a bounded queue. Use separate replicas to serve parallel traffic. `GET /healthz` returns `{"status":"ok"}`. `GET /readyz` returns `{"status":"ready"}` after the model backend is selected, or HTTP 503 with `{"status":"not_ready"}` before then. These two health endpoints do not require the bearer key and do not return model metadata.
+
+Build the container from the downloaded package, then mount its model weights read-only. Set `GPC1_API_KEY` in your environment before launching:
+
+```bash
+docker build -t gpc-1 .
+docker run --gpus all --rm -p 127.0.0.1:8000:8000 \
+  -e GPC1_API_KEY -e GPC1_MODEL_PATH=/models/gpc-1 \
+  -v "$PWD/model:/models/gpc-1:ro" gpc-1
+```
+
+For internet-facing deployment, put an HTTPS proxy in front of the server. Keep the bearer key server-side and configure request-size limits at the proxy too.
+
+### Context window
+
+The release server admits up to **256K tokens (262,144)** per compiled input, matching the backbone's configured context capacity. This includes prompt formatting, schema, choices, numeric field definitions, and image tokens, not just the supplied text. Inputs are never silently truncated.
+
+This is the configured ceiling, not a completed 256K GPU validation or a guarantee that every request fits on one GPU. Memory and latency depend on input length, images, and candidate count. Set `GPC1_MAX_INPUT_TOKENS` lower for your hardware. The hosted ZeroGPU demo uses a separate 8,192-token limit.
+
+Finite-joint requests also have an aggregate padded-token budget, defaulting to twice the input ceiling (524,288 tokens). Larger candidate sets may reach that budget before the per-input ceiling. Request-body and output-memory limits remain independent.
+
+| Setting | Default |
+| --- | --- |
+| `GPC1_MAX_INPUT_TOKENS` | 262,144; configurable from 1 to 262,144 |
+| `GPC1_MAX_CONCURRENCY` | 1, required; use replicas for parallel traffic |
+| `GPC1_MAX_PENDING_REQUESTS` | 4 waiting requests; one additional request may be active |
+| `GPC1_MAX_QUEUE_WAIT_SECONDS` | 2 |
+| `GPC1_MAX_BODY_BYTES` | 16 MiB |
+| `GPC1_MAX_IMAGE_BYTES` | 3 MiB |
+| `GPC1_MAX_IMAGE_PIXELS` | 16,777,216 |
+| `GPC1_IMAGE_CACHE_MB` | 64; one image's vision features, or 0 to disable |
+| `GPC1_MAX_JOINT_ROWS` | 32 |
+| `GPC1_MAX_PADDED_TOKENS` | `max(131072, 2 × GPC1_MAX_INPUT_TOKENS)`; 524,288 by default |
+| `GPC1_MAX_LOGIT_VECTORS` | 512 |
+| `GPC1_MAX_LOGITS_BYTES` | 512 MiB |
+
+Over-limit inputs are rejected, never truncated. POST requests require `Content-Length`. A full queue or an expired queue wait returns HTTP 429 with code `server_busy`; body and image size limits return 413. Set `GPC1_ADMIT_VISION_NUMERIC=disabled` or `GPC1_ADMIT_FINITE_JOINT=disabled` to disable those modes.
+
+Repeated requests for the same processed image can reuse its vision features without changing the prediction math. A new image still requires encoding. The cache stays in memory, holds at most one image's features, and can be disabled with `GPC1_IMAGE_CACHE_MB=0`.
+
+## Unsupported
+
+Streaming, tools, audio, remote image fetching, atomic image classification, image-conditioned finite-joint output, and unrestricted JSON generation. Omit `temperature` and `max_completion_tokens`; they are rejected rather than ignored.
+
+[Setup](README.md#get-started) · [Downloads and CI](docs/DOWNLOADS.md) · [Architecture](docs/ARCHITECTURE.md) · [Model card](MODEL_CARD.md)

Dockerfile

@@ -0,0 +1,21 @@
+FROM nvidia/cuda:13.0.1-cudnn-runtime-ubuntu24.04
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    HF_HUB_OFFLINE=1 \
+    TRANSFORMERS_OFFLINE=1 \
+    GPC1_MAX_CONCURRENCY=1
+WORKDIR /srv/gpc1
+RUN apt-get update && apt-get install -y --no-install-recommends python3.12 python3-pip \
+    && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt ./
+RUN python3.12 -m pip install --no-cache-dir --break-system-packages \
+    --index-url https://download.pytorch.org/whl/cu130 torch==2.9.1 torchvision==0.24.1 \
+    && python3.12 -m pip install --no-cache-dir --break-system-packages -r requirements.txt
+COPY gpc1_server ./gpc1_server
+COPY assets ./assets
+COPY adapter ./adapter
+RUN useradd --create-home --uid 10001 gpc1 && chown -R gpc1:gpc1 /srv/gpc1
+USER gpc1
+EXPOSE 8000
+CMD ["python3.12", "-m", "uvicorn", "gpc1_server.api:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1", "--no-access-log"]

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Alibaba Cloud
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MODEL_CARD.md

@@ -0,0 +1,30 @@
+# GPC-1 model card
+
+GPC-1 is a structured prediction model based on Qwen3.5-35B-A3B. It supports categorical choices, bounded numeric estimates, image-conditioned coordinates, and complete records selected from a caller-defined set.
+
+## Model details
+
+| Property | Value |
+| --- | --- |
+| API model ID | `gpc-1` |
+| Backbone family | `Qwen/Qwen3.5-35B-A3B` |
+| Architecture | Multimodal mixture of experts |
+| Distribution | GPC-1 backbone and matching adapter |
+| Runtime | NVIDIA, BF16, Transformers / PyTorch |
+| Categorical support | 2–255 caller-defined choices |
+| Numeric support | 101 positions per declared range |
+| Joint output | Caller-enumerated complete records |
+| Server input ceiling | 256K tokens (262,144), including compiled request overhead |
+| License | Apache-2.0, with applicable third-party notices |
+
+The release package contains GPC-1's backbone weights and matching adapter. The runtime loads and verifies both. See [setup](README.md#get-started), [download options](docs/DOWNLOADS.md), and [context configuration](API.md#context-window).
+
+## Intended use
+
+Document and message classification, bounded numerical estimates, image-coordinate annotation, and structured workflow decisions. Define labels, units, and reference frames explicitly in each request.
+
+Validate application-specific accuracy before using predictions in medical, legal, financial, or safety-critical decisions. The [API guide](API.md) defines score interpretation and supported output structures.
+
+## License
+
+GPC-1 inference code and the Qwen base use Apache-2.0. Preserve applicable upstream notices. Example media retain their own licenses. See [LICENSE](LICENSE), [NOTICE](NOTICE), and [attribution](docs/DATA_AND_LICENSES.md).

NOTICE

@@ -0,0 +1,16 @@
+GPC-1
+
+This distribution includes original GPC-1 inference software licensed under
+the Apache License, Version 2.0.
+
+GPC-1 is designed for and may be distributed with an adapter for
+Qwen/Qwen3.5-35B-A3B at revision
+59d61f3ce65a6d9863b86d2e96597125219dc754. The upstream Qwen model is
+licensed under the Apache License, Version 2.0. Preserve all applicable
+upstream copyright, patent, trademark, and attribution notices.
+
+Qwen model source: https://huggingface.co/Qwen/Qwen3.5-35B-A3B
+Pinned license: https://huggingface.co/Qwen/Qwen3.5-35B-A3B/blob/59d61f3ce65a6d9863b86d2e96597125219dc754/LICENSE
+
+Third-party attributions and example-media licenses are documented in
+docs/DATA_AND_LICENSES.md.

README.md

@@ -0,0 +1,132 @@
+---
+license: apache-2.0
+base_model: Qwen/Qwen3.5-35B-A3B
+library_name: transformers
+base_model_relation: adapter
+inference: false
+tags:
+  - classification
+  - structured-prediction
+  - multimodal
+  - peft
+  - lora
+---
+
+# GPC-1
+
+Introducing **GPC-1**, a general-purpose classifier based on **Qwen3.5-35B-A3B**, post-trained for categorical decisions, bounded numerical estimates, and image-conditioned coordinates.
+
+Define your labels, numeric ranges, or allowed JSON records through one API. Build document routing, scoring, visual annotation, and structured workflows around outputs your application can use directly. Multiple numeric fields are evaluated in one model pass.
+
+[Demo](https://huggingface.co/spaces/harshatheg/GPC-1-Demo) · [Get started](#get-started) · [Download options](docs/DOWNLOADS.md) · [API guide](API.md) · [Local demo](demo/README.md) · [Model card](MODEL_CARD.md)
+
+## Key features
+
+- **Categorical classification:** supply your own labels and receive a selected class with probabilities over the available choices.
+- **Continuous range selections:** specify bounds and a field description to obtain a numerical estimate.
+- **Image-conditioned numerical outputs:** ask for coordinates using the image and a natural-language description of the target.
+- **Dependent structured choices:** score complete allowed JSON records together to keep related categorical decisions consistent.
+- **OpenAI-style serving:** use familiar messages and JSON schemas on NVIDIA hardware.
+
+## Continuous range selections
+
+Define the range, units, and reference frame for each numeric field. The same interface can represent a position, angle, distance, or score.
+
+For example, `0` to `1` can describe a horizontal image coordinate, while `0` to `360` can describe an angle in degrees.
+
+```json
+{
+  "key": "x_coord",
+  "description": "Horizontal position of the requested point; 0 is the left edge and 1 is the right edge",
+  "minimum": 0,
+  "maximum": 1,
+  "unit": "image-width fraction"
+}
+```
+
+Each field uses 101 evenly spaced positions. The API returns the most likely position and a probability-weighted mean that can fall between positions. These are finite-resolution estimates. [Output semantics](API.md#numeric101).
+
+## Examples
+
+### Bounding boxes
+
+Four normalized coordinates define two corners: `x_min`, `y_min`, `x_max`, and `y_max`, with the origin at the image’s top-left. [Image request format](API.md#images).
+
+![Bounding box predicted by GPC-1 for the runner in red](assets/examples/bounding-box.png)
+
+### Human pose and keypoints
+
+Describe a landmark and request its coordinates, such as `right_hip_x` and `right_hip_y`. Each coordinate is a separate numeric estimate; a complete skeleton is not enforced.
+
+![Human pose example with a tennis player](assets/examples/visual-coordinates.png)
+
+### Intent classification
+
+Define intent labels in the request and receive a selected label with probabilities over those labels.
+
+![Intent-classification example](assets/examples/intent-classification.png)
+
+### Numerical request
+
+> “A tank holds 200 liters. It is 35% full. Return the current volume of liquid in liters.”
+
+Define `volume` over `0–200`, with units `liters`. GPC-1 returns `70` as the most likely value. The same numeric interface can express a rating, distance, fraction, or image coordinate; the prompt supplies the interpretation.
+
+### Dependent decisions
+
+Instead of independently choosing a department and an action, provide the complete records your workflow permits. GPC-1 scores those records together, so an invalid combination cannot appear in the returned support. Joint scoring is bounded by the records you enumerate, not arbitrary JSON generation.
+
+See the [API guide](API.md) for request payloads and response fields.
+
+## Get started
+
+Run GPC-1 on compatible NVIDIA hardware with enough memory for the BF16 model. The complete release includes the GPC-1 backbone, its matching adapter, and serving code. The server loads both weight components automatically.
+
+```bash
+python3 -m pip install "huggingface-hub>=1.7,<2"
+hf download harshatheg/GPC-1 --local-dir gpc-1
+python gpc-1/download.py verify gpc-1
+cd gpc-1
+python3 -m pip install --index-url https://download.pytorch.org/whl/cu130 torch==2.9.1 torchvision==0.24.1
+python3 -m pip install -r requirements.txt
+export GPC1_MODEL_PATH="$PWD/model"
+export GPC1_API_KEY="$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')"
+python3 -m uvicorn gpc1_server.api:app \
+  --host 127.0.0.1 --port 8000 --no-access-log
+```
+
+Keep the server running. In another terminal, open `gpc-1`, set `GPC1_API_KEY` to the same key used by the server, and send an OpenAI-style request to `/v1/chat/completions`:
+
+```bash
+curl http://127.0.0.1:8000/v1/chat/completions \
+  -H "Authorization: Bearer $GPC1_API_KEY" \
+  -H "Content-Type: application/json" \
+  --data @examples/atomic_request.json
+```
+
+The API uses familiar `messages` and `response_format` fields, with a `gpc1` extension for the prediction mode. See [serving and examples](API.md) for numeric ranges, image inputs, joint records, and deployment configuration. The [download guide](docs/DOWNLOADS.md) covers pinned revisions, Python, CI, and offline deployment.
+
+## At a glance
+
+| Model detail | GPC-1 |
+| --- | --- |
+| Backbone family | Qwen3.5-35B-A3B |
+| Packaged weights | GPC-1 backbone + matching adapter |
+| Architecture | Multimodal mixture of experts |
+| Categorical choices | 2–255 per request |
+| Numeric outputs | 101-point support over a range you define |
+| Image interface | Image-conditioned numeric fields |
+| Dependent outputs | Enumerated joint records |
+| Server input ceiling | 256K tokens (262,144), including compiled schema and image tokens |
+| Serving | NVIDIA / PyTorch, OpenAI-style HTTP API |
+| License | Apache-2.0 |
+
+See [context and deployment](API.md#context-window) for hardware requirements and the hosted demo's separate limits.
+
+## Under the hood
+
+GPC-1 uses schema-bound scoring to return typed predictions from its multimodal backbone and matching adapter. Numeric fields share one model pass; dependent categorical decisions are scored as complete allowed records.
+
+[Architecture](docs/ARCHITECTURE.md) · [Model card](MODEL_CARD.md) · [API documentation](API.md) · [Local demo](demo/README.md) · [License](LICENSE) · [Notices](NOTICE)
+
+GPC-1 inference code is Apache-2.0. The Qwen base retains its upstream license and notices; [third-party attribution](docs/DATA_AND_LICENSES.md) is included with the package.

adapter/adapter_config.json

@@ -0,0 +1,43 @@
+{
+  "alora_invocation_tokens": null,
+  "alpha_pattern": {},
+  "arrow_config": null,
+  "auto_mapping": null,
+  "base_model_name_or_path": "model",
+  "bias": "none",
+  "corda_config": null,
+  "ensure_weight_tying": false,
+  "eva_config": null,
+  "exclude_modules": null,
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "kasa_config": null,
+  "layer_replication": null,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 16,
+  "lora_bias": false,
+  "lora_dropout": 0.0,
+  "lora_ga_config": null,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "monteclora_config": null,
+  "peft_type": "LORA",
+  "peft_version": "0.21.0",
+  "qalora_group_size": 16,
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": ".*language_model.*\\.(q_proj|k_proj|v_proj|o_proj|in_proj_qkv|out_proj)$",
+  "target_parameters": null,
+  "task_type": "CAUSAL_LM",
+  "trainable_token_indices": null,
+  "use_bdlora": null,
+  "use_dora": false,
+  "use_qalora": false,
+  "use_rslora": false,
+  "velora_config": null
+}

adapter/adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b2521cff2a98afdd42e3051c8c6de60ad928b1268244f2c13b4193059c6e1f4
+size 45250376

assets/base_files.sha256.json

@@ -0,0 +1,32 @@
+{
+  "files": {
+    "chat_template.jinja": "a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715",
+    "config.json": "5e4d7f74fec2f360eb9cfbfcd6ec0c4c76e684d3a11caaed259d9fd9bfbc7944",
+    "generation_config.json": "4f25002776b741773666203dcea8f54619f177ace3ae483d311102092a4658e0",
+    "merges.txt": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+    "model-00001-of-00016.safetensors": "43a908b3d324d59b66c73a33e5c182809eb2df7da474b2fd2cbdabb16baeee38",
+    "model-00002-of-00016.safetensors": "4de54e39c2ecc6f3fb5e79e752f84b65c96c316d0d848c9b55d36a062df69e70",
+    "model-00003-of-00016.safetensors": "847472ab2e3e10da0baea3993890ce393cc1b364f53674a00a92ac6ed856ec0d",
+    "model-00004-of-00016.safetensors": "81b2b46905d62b66c6a0d2360050c266ea9416f913708e9a1447b28465f458f0",
+    "model-00005-of-00016.safetensors": "3a13dfef35c76070c92e7a303640f90b11795dd1ecc6e501d0e00d8310b0e3a2",
+    "model-00006-of-00016.safetensors": "baeb2742c637cb517e6410c1b7dc53ea69312078a1f0b708d43d7a62dffa22a9",
+    "model-00007-of-00016.safetensors": "5cc9bcd2e0a8e17f1319f8d808fd6595d9944f2a0e01e9e7cb8d550b9646e413",
+    "model-00008-of-00016.safetensors": "f294ac742f1f1762b8f05963812b33dd3bff1701b0ec887fe46717c7d66a638e",
+    "model-00009-of-00016.safetensors": "2198de19b6c6eda23f6b72f787f861ee4495ff9f29551f3b40cef72f1afbd96d",
+    "model-00010-of-00016.safetensors": "3fecc834fc976ae9205039b01c53049f18ca5b68d973f0977bfe90335faf0918",
+    "model-00011-of-00016.safetensors": "4e253c10600a5368df08bdd92e97c69c4b3b59fc4e7d8326a5f33b0888358779",
+    "model-00012-of-00016.safetensors": "420af5489aecba4d174c875520e3fcf5180ead42c9c6d8bc903ce8cb910f996c",
+    "model-00013-of-00016.safetensors": "a2b5627ba8a9b4564a795388ee90c757abb0f386aa6bef813ff3b6c52a9a85f7",
+    "model-00014-of-00016.safetensors": "e52489ba1847e0b1d89a445fa4f3b26dd1f2e957c70b35657e6333ea9be8f12a",
+    "model-00015-of-00016.safetensors": "7ef51deb1d96fe34a37d8bec88b4f7151c0ac762b802fe446c990ed4580bbb67",
+    "model-00016-of-00016.safetensors": "4df5299dd7e8033e6821336584fd5b8830c116cdea7385e64e3b0c2b14609ea8",
+    "model.safetensors.index.json": "f8448aa8b2fbf3519723b0c2965fc94ed64cafdd463381636a1df351952b3f1a",
+    "preprocessor_config.json": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+    "tokenizer.json": "5f9e4d4901a92b997e463c1f46055088b6cca5ca61a6522d1b9f64c4bb81cb42",
+    "tokenizer_config.json": "316230d6a809701f4db5ea8f8fc862bc3a6f3229c937c174e674ff3ca0a64ac8",
+    "video_preprocessor_config.json": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+    "vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003"
+  },
+  "model_id": "harshatheg/GPC-1",
+  "revision": "base-278124e95f96d21b"
+}

assets/codebook255.json

@@ -0,0 +1,1532 @@
+[
+  {
+    "code": "A",
+    "position": 0,
+    "token_id": 32,
+    "utf8_hex": "41"
+  },
+  {
+    "code": "B",
+    "position": 1,
+    "token_id": 33,
+    "utf8_hex": "42"
+  },
+  {
+    "code": "C",
+    "position": 2,
+    "token_id": 34,
+    "utf8_hex": "43"
+  },
+  {
+    "code": "D",
+    "position": 3,
+    "token_id": 35,
+    "utf8_hex": "44"
+  },
+  {
+    "code": "E",
+    "position": 4,
+    "token_id": 36,
+    "utf8_hex": "45"
+  },
+  {
+    "code": "F",
+    "position": 5,
+    "token_id": 37,
+    "utf8_hex": "46"
+  },
+  {
+    "code": "G",
+    "position": 6,
+    "token_id": 38,
+    "utf8_hex": "47"
+  },
+  {
+    "code": "H",
+    "position": 7,
+    "token_id": 39,
+    "utf8_hex": "48"
+  },
+  {
+    "code": "I",
+    "position": 8,
+    "token_id": 40,
+    "utf8_hex": "49"
+  },
+  {
+    "code": "J",
+    "position": 9,
+    "token_id": 41,
+    "utf8_hex": "4a"
+  },
+  {
+    "code": "K",
+    "position": 10,
+    "token_id": 42,
+    "utf8_hex": "4b"
+  },
+  {
+    "code": "L",
+    "position": 11,
+    "token_id": 43,
+    "utf8_hex": "4c"
+  },
+  {
+    "code": "M",
+    "position": 12,
+    "token_id": 44,
+    "utf8_hex": "4d"
+  },
+  {
+    "code": "N",
+    "position": 13,
+    "token_id": 45,
+    "utf8_hex": "4e"
+  },
+  {
+    "code": "O",
+    "position": 14,
+    "token_id": 46,
+    "utf8_hex": "4f"
+  },
+  {
+    "code": "P",
+    "position": 15,
+    "token_id": 47,
+    "utf8_hex": "50"
+  },
+  {
+    "code": "Q",
+    "position": 16,
+    "token_id": 48,
+    "utf8_hex": "51"
+  },
+  {
+    "code": "R",
+    "position": 17,
+    "token_id": 49,
+    "utf8_hex": "52"
+  },
+  {
+    "code": "S",
+    "position": 18,
+    "token_id": 50,
+    "utf8_hex": "53"
+  },
+  {
+    "code": "T",
+    "position": 19,
+    "token_id": 51,
+    "utf8_hex": "54"
+  },
+  {
+    "code": "U",
+    "position": 20,
+    "token_id": 52,
+    "utf8_hex": "55"
+  },
+  {
+    "code": "V",
+    "position": 21,
+    "token_id": 53,
+    "utf8_hex": "56"
+  },
+  {
+    "code": "W",
+    "position": 22,
+    "token_id": 54,
+    "utf8_hex": "57"
+  },
+  {
+    "code": "X",
+    "position": 23,
+    "token_id": 55,
+    "utf8_hex": "58"
+  },
+  {
+    "code": "Y",
+    "position": 24,
+    "token_id": 56,
+    "utf8_hex": "59"
+  },
+  {
+    "code": "Z",
+    "position": 25,
+    "token_id": 57,
+    "utf8_hex": "5a"
+  },
+  {
+    "code": "AA",
+    "position": 26,
+    "token_id": 5840,
+    "utf8_hex": "4141"
+  },
+  {
+    "code": "AB",
+    "position": 27,
+    "token_id": 1803,
+    "utf8_hex": "4142"
+  },
+  {
+    "code": "AC",
+    "position": 28,
+    "token_id": 1646,
+    "utf8_hex": "4143"
+  },
+  {
+    "code": "AD",
+    "position": 29,
+    "token_id": 1745,
+    "utf8_hex": "4144"
+  },
+  {
+    "code": "AE",
+    "position": 30,
+    "token_id": 13276,
+    "utf8_hex": "4145"
+  },
+  {
+    "code": "AF",
+    "position": 31,
+    "token_id": 8018,
+    "utf8_hex": "4146"
+  },
+  {
+    "code": "AG",
+    "position": 32,
+    "token_id": 1825,
+    "utf8_hex": "4147"
+  },
+  {
+    "code": "AH",
+    "position": 33,
+    "token_id": 28946,
+    "utf8_hex": "4148"
+  },
+  {
+    "code": "AI",
+    "position": 34,
+    "token_id": 15015,
+    "utf8_hex": "4149"
+  },
+  {
+    "code": "AJ",
+    "position": 35,
+    "token_id": 29595,
+    "utf8_hex": "414a"
+  },
+  {
+    "code": "AK",
+    "position": 36,
+    "token_id": 11568,
+    "utf8_hex": "414b"
+  },
+  {
+    "code": "AL",
+    "position": 37,
+    "token_id": 939,
+    "utf8_hex": "414c"
+  },
+  {
+    "code": "AM",
+    "position": 38,
+    "token_id": 1354,
+    "utf8_hex": "414d"
+  },
+  {
+    "code": "AN",
+    "position": 39,
+    "token_id": 1058,
+    "utf8_hex": "414e"
+  },
+  {
+    "code": "AO",
+    "position": 40,
+    "token_id": 18183,
+    "utf8_hex": "414f"
+  },
+  {
+    "code": "AP",
+    "position": 41,
+    "token_id": 2456,
+    "utf8_hex": "4150"
+  },
+  {
+    "code": "AQ",
+    "position": 42,
+    "token_id": 88898,
+    "utf8_hex": "4151"
+  },
+  {
+    "code": "AR",
+    "position": 43,
+    "token_id": 905,
+    "utf8_hex": "4152"
+  },
+  {
+    "code": "AS",
+    "position": 44,
+    "token_id": 1846,
+    "utf8_hex": "4153"
+  },
+  {
+    "code": "AT",
+    "position": 45,
+    "token_id": 802,
+    "utf8_hex": "4154"
+  },
+  {
+    "code": "AU",
+    "position": 46,
+    "token_id": 33869,
+    "utf8_hex": "4155"
+  },
+  {
+    "code": "AV",
+    "position": 47,
+    "token_id": 7839,
+    "utf8_hex": "4156"
+  },
+  {
+    "code": "AW",
+    "position": 48,
+    "token_id": 14006,
+    "utf8_hex": "4157"
+  },
+  {
+    "code": "AX",
+    "position": 49,
+    "token_id": 2860,
+    "utf8_hex": "4158"
+  },
+  {
+    "code": "AY",
+    "position": 50,
+    "token_id": 2926,
+    "utf8_hex": "4159"
+  },
+  {
+    "code": "AZ",
+    "position": 51,
+    "token_id": 22828,
+    "utf8_hex": "415a"
+  },
+  {
+    "code": "BA",
+    "position": 52,
+    "token_id": 6844,
+    "utf8_hex": "4241"
+  },
+  {
+    "code": "BB",
+    "position": 53,
+    "token_id": 9798,
+    "utf8_hex": "4242"
+  },
+  {
+    "code": "BC",
+    "position": 54,
+    "token_id": 4738,
+    "utf8_hex": "4243"
+  },
+  {
+    "code": "BD",
+    "position": 55,
+    "token_id": 9265,
+    "utf8_hex": "4244"
+  },
+  {
+    "code": "BE",
+    "position": 56,
+    "token_id": 11261,
+    "utf8_hex": "4245"
+  },
+  {
+    "code": "BF",
+    "position": 57,
+    "token_id": 19278,
+    "utf8_hex": "4246"
+  },
+  {
+    "code": "BG",
+    "position": 58,
+    "token_id": 36513,
+    "utf8_hex": "4247"
+  },
+  {
+    "code": "BH",
+    "position": 59,
+    "token_id": 93801,
+    "utf8_hex": "4248"
+  },
+  {
+    "code": "BI",
+    "position": 60,
+    "token_id": 8335,
+    "utf8_hex": "4249"
+  },
+  {
+    "code": "BJ",
+    "position": 61,
+    "token_id": 14544,
+    "utf8_hex": "424a"
+  },
+  {
+    "code": "BK",
+    "position": 62,
+    "token_id": 85266,
+    "utf8_hex": "424b"
+  },
+  {
+    "code": "BL",
+    "position": 63,
+    "token_id": 9110,
+    "utf8_hex": "424c"
+  },
+  {
+    "code": "BM",
+    "position": 64,
+    "token_id": 28000,
+    "utf8_hex": "424d"
+  },
+  {
+    "code": "BN",
+    "position": 65,
+    "token_id": 15137,
+    "utf8_hex": "424e"
+  },
+  {
+    "code": "BO",
+    "position": 66,
+    "token_id": 4525,
+    "utf8_hex": "424f"
+  },
+  {
+    "code": "BP",
+    "position": 67,
+    "token_id": 25261,
+    "utf8_hex": "4250"
+  },
+  {
+    "code": "BR",
+    "position": 68,
+    "token_id": 12717,
+    "utf8_hex": "4252"
+  },
+  {
+    "code": "BS",
+    "position": 69,
+    "token_id": 7116,
+    "utf8_hex": "4253"
+  },
+  {
+    "code": "BT",
+    "position": 70,
+    "token_id": 17078,
+    "utf8_hex": "4254"
+  },
+  {
+    "code": "BU",
+    "position": 71,
+    "token_id": 14497,
+    "utf8_hex": "4255"
+  },
+  {
+    "code": "BV",
+    "position": 72,
+    "token_id": 57339,
+    "utf8_hex": "4256"
+  },
+  {
+    "code": "BW",
+    "position": 73,
+    "token_id": 74909,
+    "utf8_hex": "4257"
+  },
+  {
+    "code": "BX",
+    "position": 74,
+    "token_id": 52072,
+    "utf8_hex": "4258"
+  },
+  {
+    "code": "BY",
+    "position": 75,
+    "token_id": 19305,
+    "utf8_hex": "4259"
+  },
+  {
+    "code": "CA",
+    "position": 76,
+    "token_id": 4887,
+    "utf8_hex": "4341"
+  },
+  {
+    "code": "CB",
+    "position": 77,
+    "token_id": 12607,
+    "utf8_hex": "4342"
+  },
+  {
+    "code": "CC",
+    "position": 78,
+    "token_id": 3580,
+    "utf8_hex": "4343"
+  },
+  {
+    "code": "CD",
+    "position": 79,
+    "token_id": 6281,
+    "utf8_hex": "4344"
+  },
+  {
+    "code": "CE",
+    "position": 80,
+    "token_id": 2036,
+    "utf8_hex": "4345"
+  },
+  {
+    "code": "CF",
+    "position": 81,
+    "token_id": 9362,
+    "utf8_hex": "4346"
+  },
+  {
+    "code": "CG",
+    "position": 82,
+    "token_id": 8533,
+    "utf8_hex": "4347"
+  },
+  {
+    "code": "CH",
+    "position": 83,
+    "token_id": 2080,
+    "utf8_hex": "4348"
+  },
+  {
+    "code": "CI",
+    "position": 84,
+    "token_id": 10911,
+    "utf8_hex": "4349"
+  },
+  {
+    "code": "CK",
+    "position": 85,
+    "token_id": 2925,
+    "utf8_hex": "434b"
+  },
+  {
+    "code": "CL",
+    "position": 86,
+    "token_id": 3040,
+    "utf8_hex": "434c"
+  },
+  {
+    "code": "CM",
+    "position": 87,
+    "token_id": 9690,
+    "utf8_hex": "434d"
+  },
+  {
+    "code": "CN",
+    "position": 88,
+    "token_id": 27731,
+    "utf8_hex": "434e"
+  },
+  {
+    "code": "CO",
+    "position": 89,
+    "token_id": 8023,
+    "utf8_hex": "434f"
+  },
+  {
+    "code": "CP",
+    "position": 90,
+    "token_id": 6901,
+    "utf8_hex": "4350"
+  },
+  {
+    "code": "CR",
+    "position": 91,
+    "token_id": 8702,
+    "utf8_hex": "4352"
+  },
+  {
+    "code": "CS",
+    "position": 92,
+    "token_id": 6211,
+    "utf8_hex": "4353"
+  },
+  {
+    "code": "CT",
+    "position": 93,
+    "token_id": 1123,
+    "utf8_hex": "4354"
+  },
+  {
+    "code": "CU",
+    "position": 94,
+    "token_id": 16307,
+    "utf8_hex": "4355"
+  },
+  {
+    "code": "CV",
+    "position": 95,
+    "token_id": 18990,
+    "utf8_hex": "4356"
+  },
+  {
+    "code": "CW",
+    "position": 96,
+    "token_id": 64045,
+    "utf8_hex": "4357"
+  },
+  {
+    "code": "CX",
+    "position": 97,
+    "token_id": 63037,
+    "utf8_hex": "4358"
+  },
+  {
+    "code": "CY",
+    "position": 98,
+    "token_id": 33380,
+    "utf8_hex": "4359"
+  },
+  {
+    "code": "DA",
+    "position": 99,
+    "token_id": 6151,
+    "utf8_hex": "4441"
+  },
+  {
+    "code": "DB",
+    "position": 100,
+    "token_id": 3392,
+    "utf8_hex": "4442"
+  },
+  {
+    "code": "DC",
+    "position": 101,
+    "token_id": 5449,
+    "utf8_hex": "4443"
+  },
+  {
+    "code": "DD",
+    "position": 102,
+    "token_id": 3967,
+    "utf8_hex": "4444"
+  },
+  {
+    "code": "DE",
+    "position": 103,
+    "token_id": 1113,
+    "utf8_hex": "4445"
+  },
+  {
+    "code": "DF",
+    "position": 104,
+    "token_id": 5095,
+    "utf8_hex": "4446"
+  },
+  {
+    "code": "DG",
+    "position": 105,
+    "token_id": 51923,
+    "utf8_hex": "4447"
+  },
+  {
+    "code": "DH",
+    "position": 106,
+    "token_id": 49600,
+    "utf8_hex": "4448"
+  },
+  {
+    "code": "DI",
+    "position": 107,
+    "token_id": 17099,
+    "utf8_hex": "4449"
+  },
+  {
+    "code": "DJ",
+    "position": 108,
+    "token_id": 51483,
+    "utf8_hex": "444a"
+  },
+  {
+    "code": "DK",
+    "position": 109,
+    "token_id": 17756,
+    "utf8_hex": "444b"
+  },
+  {
+    "code": "DL",
+    "position": 110,
+    "token_id": 16037,
+    "utf8_hex": "444c"
+  },
+  {
+    "code": "DM",
+    "position": 111,
+    "token_id": 8135,
+    "utf8_hex": "444d"
+  },
+  {
+    "code": "DN",
+    "position": 112,
+    "token_id": 30237,
+    "utf8_hex": "444e"
+  },
+  {
+    "code": "DO",
+    "position": 113,
+    "token_id": 5683,
+    "utf8_hex": "444f"
+  },
+  {
+    "code": "DP",
+    "position": 114,
+    "token_id": 9992,
+    "utf8_hex": "4450"
+  },
+  {
+    "code": "DR",
+    "position": 115,
+    "token_id": 7444,
+    "utf8_hex": "4452"
+  },
+  {
+    "code": "DS",
+    "position": 116,
+    "token_id": 5751,
+    "utf8_hex": "4453"
+  },
+  {
+    "code": "DT",
+    "position": 117,
+    "token_id": 10284,
+    "utf8_hex": "4454"
+  },
+  {
+    "code": "DU",
+    "position": 118,
+    "token_id": 20887,
+    "utf8_hex": "4455"
+  },
+  {
+    "code": "DV",
+    "position": 119,
+    "token_id": 59884,
+    "utf8_hex": "4456"
+  },
+  {
+    "code": "DW",
+    "position": 120,
+    "token_id": 52396,
+    "utf8_hex": "4457"
+  },
+  {
+    "code": "DX",
+    "position": 121,
+    "token_id": 16103,
+    "utf8_hex": "4458"
+  },
+  {
+    "code": "DY",
+    "position": 122,
+    "token_id": 67547,
+    "utf8_hex": "4459"
+  },
+  {
+    "code": "EA",
+    "position": 123,
+    "token_id": 18535,
+    "utf8_hex": "4541"
+  },
+  {
+    "code": "EB",
+    "position": 124,
+    "token_id": 8006,
+    "utf8_hex": "4542"
+  },
+  {
+    "code": "EC",
+    "position": 125,
+    "token_id": 7263,
+    "utf8_hex": "4543"
+  },
+  {
+    "code": "ED",
+    "position": 126,
+    "token_id": 1425,
+    "utf8_hex": "4544"
+  },
+  {
+    "code": "EE",
+    "position": 127,
+    "token_id": 6878,
+    "utf8_hex": "4545"
+  },
+  {
+    "code": "EF",
+    "position": 128,
+    "token_id": 14453,
+    "utf8_hex": "4546"
+  },
+  {
+    "code": "EG",
+    "position": 129,
+    "token_id": 9097,
+    "utf8_hex": "4547"
+  },
+  {
+    "code": "EH",
+    "position": 130,
+    "token_id": 44072,
+    "utf8_hex": "4548"
+  },
+  {
+    "code": "EI",
+    "position": 131,
+    "token_id": 76089,
+    "utf8_hex": "4549"
+  },
+  {
+    "code": "EK",
+    "position": 132,
+    "token_id": 68720,
+    "utf8_hex": "454b"
+  },
+  {
+    "code": "EL",
+    "position": 133,
+    "token_id": 2662,
+    "utf8_hex": "454c"
+  },
+  {
+    "code": "EM",
+    "position": 134,
+    "token_id": 2629,
+    "utf8_hex": "454d"
+  },
+  {
+    "code": "EN",
+    "position": 135,
+    "token_id": 923,
+    "utf8_hex": "454e"
+  },
+  {
+    "code": "EO",
+    "position": 136,
+    "token_id": 6548,
+    "utf8_hex": "454f"
+  },
+  {
+    "code": "EP",
+    "position": 137,
+    "token_id": 8924,
+    "utf8_hex": "4550"
+  },
+  {
+    "code": "EQ",
+    "position": 138,
+    "token_id": 52194,
+    "utf8_hex": "4551"
+  },
+  {
+    "code": "ER",
+    "position": 139,
+    "token_id": 622,
+    "utf8_hex": "4552"
+  },
+  {
+    "code": "ES",
+    "position": 140,
+    "token_id": 1515,
+    "utf8_hex": "4553"
+  },
+  {
+    "code": "ET",
+    "position": 141,
+    "token_id": 1300,
+    "utf8_hex": "4554"
+  },
+  {
+    "code": "EU",
+    "position": 142,
+    "token_id": 37523,
+    "utf8_hex": "4555"
+  },
+  {
+    "code": "EV",
+    "position": 143,
+    "token_id": 44473,
+    "utf8_hex": "4556"
+  },
+  {
+    "code": "EW",
+    "position": 144,
+    "token_id": 36530,
+    "utf8_hex": "4557"
+  },
+  {
+    "code": "EX",
+    "position": 145,
+    "token_id": 3152,
+    "utf8_hex": "4558"
+  },
+  {
+    "code": "EZ",
+    "position": 146,
+    "token_id": 93924,
+    "utf8_hex": "455a"
+  },
+  {
+    "code": "FA",
+    "position": 147,
+    "token_id": 3505,
+    "utf8_hex": "4641"
+  },
+  {
+    "code": "FB",
+    "position": 148,
+    "token_id": 15731,
+    "utf8_hex": "4642"
+  },
+  {
+    "code": "FC",
+    "position": 149,
+    "token_id": 6542,
+    "utf8_hex": "4643"
+  },
+  {
+    "code": "FD",
+    "position": 150,
+    "token_id": 14176,
+    "utf8_hex": "4644"
+  },
+  {
+    "code": "FE",
+    "position": 151,
+    "token_id": 11091,
+    "utf8_hex": "4645"
+  },
+  {
+    "code": "FF",
+    "position": 152,
+    "token_id": 1686,
+    "utf8_hex": "4646"
+  },
+  {
+    "code": "FG",
+    "position": 153,
+    "token_id": 11660,
+    "utf8_hex": "4647"
+  },
+  {
+    "code": "FH",
+    "position": 154,
+    "token_id": 80440,
+    "utf8_hex": "4648"
+  },
+  {
+    "code": "FI",
+    "position": 155,
+    "token_id": 18836,
+    "utf8_hex": "4649"
+  },
+  {
+    "code": "FK",
+    "position": 156,
+    "token_id": 26132,
+    "utf8_hex": "464b"
+  },
+  {
+    "code": "FL",
+    "position": 157,
+    "token_id": 5934,
+    "utf8_hex": "464c"
+  },
+  {
+    "code": "FM",
+    "position": 158,
+    "token_id": 24794,
+    "utf8_hex": "464d"
+  },
+  {
+    "code": "FN",
+    "position": 159,
+    "token_id": 40229,
+    "utf8_hex": "464e"
+  },
+  {
+    "code": "FO",
+    "position": 160,
+    "token_id": 3660,
+    "utf8_hex": "464f"
+  },
+  {
+    "code": "FP",
+    "position": 161,
+    "token_id": 11361,
+    "utf8_hex": "4650"
+  },
+  {
+    "code": "FR",
+    "position": 162,
+    "token_id": 10191,
+    "utf8_hex": "4652"
+  },
+  {
+    "code": "FS",
+    "position": 163,
+    "token_id": 8225,
+    "utf8_hex": "4653"
+  },
+  {
+    "code": "FT",
+    "position": 164,
+    "token_id": 3860,
+    "utf8_hex": "4654"
+  },
+  {
+    "code": "FU",
+    "position": 165,
+    "token_id": 78413,
+    "utf8_hex": "4655"
+  },
+  {
+    "code": "FW",
+    "position": 166,
+    "token_id": 17680,
+    "utf8_hex": "4657"
+  },
+  {
+    "code": "FX",
+    "position": 167,
+    "token_id": 15900,
+    "utf8_hex": "4658"
+  },
+  {
+    "code": "FY",
+    "position": 168,
+    "token_id": 78138,
+    "utf8_hex": "4659"
+  },
+  {
+    "code": "GA",
+    "position": 169,
+    "token_id": 15653,
+    "utf8_hex": "4741"
+  },
+  {
+    "code": "GB",
+    "position": 170,
+    "token_id": 5213,
+    "utf8_hex": "4742"
+  },
+  {
+    "code": "GC",
+    "position": 171,
+    "token_id": 22150,
+    "utf8_hex": "4743"
+  },
+  {
+    "code": "GD",
+    "position": 172,
+    "token_id": 39500,
+    "utf8_hex": "4744"
+  },
+  {
+    "code": "GE",
+    "position": 173,
+    "token_id": 10460,
+    "utf8_hex": "4745"
+  },
+  {
+    "code": "GF",
+    "position": 174,
+    "token_id": 35131,
+    "utf8_hex": "4746"
+  },
+  {
+    "code": "GG",
+    "position": 175,
+    "token_id": 21563,
+    "utf8_hex": "4747"
+  },
+  {
+    "code": "GH",
+    "position": 176,
+    "token_id": 43194,
+    "utf8_hex": "4748"
+  },
+  {
+    "code": "GI",
+    "position": 177,
+    "token_id": 27127,
+    "utf8_hex": "4749"
+  },
+  {
+    "code": "GL",
+    "position": 178,
+    "token_id": 3697,
+    "utf8_hex": "474c"
+  },
+  {
+    "code": "GM",
+    "position": 179,
+    "token_id": 20011,
+    "utf8_hex": "474d"
+  },
+  {
+    "code": "GN",
+    "position": 180,
+    "token_id": 24368,
+    "utf8_hex": "474e"
+  },
+  {
+    "code": "GO",
+    "position": 181,
+    "token_id": 15058,
+    "utf8_hex": "474f"
+  },
+  {
+    "code": "GP",
+    "position": 182,
+    "token_id": 23658,
+    "utf8_hex": "4750"
+  },
+  {
+    "code": "GR",
+    "position": 183,
+    "token_id": 8362,
+    "utf8_hex": "4752"
+  },
+  {
+    "code": "GS",
+    "position": 184,
+    "token_id": 16035,
+    "utf8_hex": "4753"
+  },
+  {
+    "code": "GT",
+    "position": 185,
+    "token_id": 24583,
+    "utf8_hex": "4754"
+  },
+  {
+    "code": "GU",
+    "position": 186,
+    "token_id": 52857,
+    "utf8_hex": "4755"
+  },
+  {
+    "code": "GV",
+    "position": 187,
+    "token_id": 38403,
+    "utf8_hex": "4756"
+  },
+  {
+    "code": "GW",
+    "position": 188,
+    "token_id": 60456,
+    "utf8_hex": "4757"
+  },
+  {
+    "code": "GX",
+    "position": 189,
+    "token_id": 81519,
+    "utf8_hex": "4758"
+  },
+  {
+    "code": "GY",
+    "position": 190,
+    "token_id": 40097,
+    "utf8_hex": "4759"
+  },
+  {
+    "code": "HA",
+    "position": 191,
+    "token_id": 16522,
+    "utf8_hex": "4841"
+  },
+  {
+    "code": "HB",
+    "position": 192,
+    "token_id": 29722,
+    "utf8_hex": "4842"
+  },
+  {
+    "code": "HC",
+    "position": 193,
+    "token_id": 21756,
+    "utf8_hex": "4843"
+  },
+  {
+    "code": "HD",
+    "position": 194,
+    "token_id": 18567,
+    "utf8_hex": "4844"
+  },
+  {
+    "code": "HE",
+    "position": 195,
+    "token_id": 1736,
+    "utf8_hex": "4845"
+  },
+  {
+    "code": "HF",
+    "position": 196,
+    "token_id": 48043,
+    "utf8_hex": "4846"
+  },
+  {
+    "code": "HG",
+    "position": 197,
+    "token_id": 87013,
+    "utf8_hex": "4847"
+  },
+  {
+    "code": "HH",
+    "position": 198,
+    "token_id": 22456,
+    "utf8_hex": "4848"
+  },
+  {
+    "code": "HI",
+    "position": 199,
+    "token_id": 23165,
+    "utf8_hex": "4849"
+  },
+  {
+    "code": "HK",
+    "position": 200,
+    "token_id": 55523,
+    "utf8_hex": "484b"
+  },
+  {
+    "code": "HL",
+    "position": 201,
+    "token_id": 13097,
+    "utf8_hex": "484c"
+  },
+  {
+    "code": "HM",
+    "position": 202,
+    "token_id": 50397,
+    "utf8_hex": "484d"
+  },
+  {
+    "code": "HN",
+    "position": 203,
+    "token_id": 41741,
+    "utf8_hex": "484e"
+  },
+  {
+    "code": "HO",
+    "position": 204,
+    "token_id": 23073,
+    "utf8_hex": "484f"
+  },
+  {
+    "code": "HP",
+    "position": 205,
+    "token_id": 6401,
+    "utf8_hex": "4850"
+  },
+  {
+    "code": "HQ",
+    "position": 206,
+    "token_id": 86538,
+    "utf8_hex": "4851"
+  },
+  {
+    "code": "HR",
+    "position": 207,
+    "token_id": 16585,
+    "utf8_hex": "4852"
+  },
+  {
+    "code": "HS",
+    "position": 208,
+    "token_id": 11622,
+    "utf8_hex": "4853"
+  },
+  {
+    "code": "HT",
+    "position": 209,
+    "token_id": 2464,
+    "utf8_hex": "4854"
+  },
+  {
+    "code": "HU",
+    "position": 210,
+    "token_id": 84982,
+    "utf8_hex": "4855"
+  },
+  {
+    "code": "HV",
+    "position": 211,
+    "token_id": 75516,
+    "utf8_hex": "4856"
+  },
+  {
+    "code": "HW",
+    "position": 212,
+    "token_id": 36984,
+    "utf8_hex": "4857"
+  },
+  {
+    "code": "HX",
+    "position": 213,
+    "token_id": 58795,
+    "utf8_hex": "4858"
+  },
+  {
+    "code": "HY",
+    "position": 214,
+    "token_id": 47217,
+    "utf8_hex": "4859"
+  },
+  {
+    "code": "HZ",
+    "position": 215,
+    "token_id": 59675,
+    "utf8_hex": "485a"
+  },
+  {
+    "code": "IA",
+    "position": 216,
+    "token_id": 5681,
+    "utf8_hex": "4941"
+  },
+  {
+    "code": "IB",
+    "position": 217,
+    "token_id": 3151,
+    "utf8_hex": "4942"
+  },
+  {
+    "code": "IC",
+    "position": 218,
+    "token_id": 1271,
+    "utf8_hex": "4943"
+  },
+  {
+    "code": "ID",
+    "position": 219,
+    "token_id": 887,
+    "utf8_hex": "4944"
+  },
+  {
+    "code": "IE",
+    "position": 220,
+    "token_id": 5203,
+    "utf8_hex": "4945"
+  },
+  {
+    "code": "IF",
+    "position": 221,
+    "token_id": 2685,
+    "utf8_hex": "4946"
+  },
+  {
+    "code": "IG",
+    "position": 222,
+    "token_id": 1849,
+    "utf8_hex": "4947"
+  },
+  {
+    "code": "IH",
+    "position": 223,
+    "token_id": 72470,
+    "utf8_hex": "4948"
+  },
+  {
+    "code": "II",
+    "position": 224,
+    "token_id": 5370,
+    "utf8_hex": "4949"
+  },
+  {
+    "code": "IJ",
+    "position": 225,
+    "token_id": 74063,
+    "utf8_hex": "494a"
+  },
+  {
+    "code": "IK",
+    "position": 226,
+    "token_id": 27629,
+    "utf8_hex": "494b"
+  },
+  {
+    "code": "IL",
+    "position": 227,
+    "token_id": 1655,
+    "utf8_hex": "494c"
+  },
+  {
+    "code": "IM",
+    "position": 228,
+    "token_id": 1728,
+    "utf8_hex": "494d"
+  },
+  {
+    "code": "IN",
+    "position": 229,
+    "token_id": 669,
+    "utf8_hex": "494e"
+  },
+  {
+    "code": "IO",
+    "position": 230,
+    "token_id": 3682,
+    "utf8_hex": "494f"
+  },
+  {
+    "code": "IP",
+    "position": 231,
+    "token_id": 3191,
+    "utf8_hex": "4950"
+  },
+  {
+    "code": "IQ",
+    "position": 232,
+    "token_id": 59865,
+    "utf8_hex": "4951"
+  },
+  {
+    "code": "IR",
+    "position": 233,
+    "token_id": 2712,
+    "utf8_hex": "4952"
+  },
+  {
+    "code": "IS",
+    "position": 234,
+    "token_id": 1580,
+    "utf8_hex": "4953"
+  },
+  {
+    "code": "IT",
+    "position": 235,
+    "token_id": 922,
+    "utf8_hex": "4954"
+  },
+  {
+    "code": "IU",
+    "position": 236,
+    "token_id": 77243,
+    "utf8_hex": "4955"
+  },
+  {
+    "code": "IV",
+    "position": 237,
+    "token_id": 2990,
+    "utf8_hex": "4956"
+  },
+  {
+    "code": "IW",
+    "position": 238,
+    "token_id": 78493,
+    "utf8_hex": "4957"
+  },
+  {
+    "code": "IX",
+    "position": 239,
+    "token_id": 5228,
+    "utf8_hex": "4958"
+  },
+  {
+    "code": "IZ",
+    "position": 240,
+    "token_id": 2750,
+    "utf8_hex": "495a"
+  },
+  {
+    "code": "JA",
+    "position": 241,
+    "token_id": 42711,
+    "utf8_hex": "4a41"
+  },
+  {
+    "code": "JB",
+    "position": 242,
+    "token_id": 44568,
+    "utf8_hex": "4a42"
+  },
+  {
+    "code": "JC",
+    "position": 243,
+    "token_id": 56402,
+    "utf8_hex": "4a43"
+  },
+  {
+    "code": "JD",
+    "position": 244,
+    "token_id": 48236,
+    "utf8_hex": "4a44"
+  },
+  {
+    "code": "JE",
+    "position": 245,
+    "token_id": 38993,
+    "utf8_hex": "4a45"
+  },
+  {
+    "code": "JI",
+    "position": 246,
+    "token_id": 43559,
+    "utf8_hex": "4a49"
+  },
+  {
+    "code": "JJ",
+    "position": 247,
+    "token_id": 61250,
+    "utf8_hex": "4a4a"
+  },
+  {
+    "code": "JK",
+    "position": 248,
+    "token_id": 32942,
+    "utf8_hex": "4a4b"
+  },
+  {
+    "code": "JM",
+    "position": 249,
+    "token_id": 86302,
+    "utf8_hex": "4a4d"
+  },
+  {
+    "code": "JO",
+    "position": 250,
+    "token_id": 25310,
+    "utf8_hex": "4a4f"
+  },
+  {
+    "code": "JP",
+    "position": 251,
+    "token_id": 26313,
+    "utf8_hex": "4a50"
+  },
+  {
+    "code": "JR",
+    "position": 252,
+    "token_id": 81770,
+    "utf8_hex": "4a52"
+  },
+  {
+    "code": "JS",
+    "position": 253,
+    "token_id": 12185,
+    "utf8_hex": "4a53"
+  },
+  {
+    "code": "JT",
+    "position": 254,
+    "token_id": 78382,
+    "utf8_hex": "4a54"
+  }
+]

assets/runtime_manifest.json

@@ -0,0 +1,37 @@
+{
+  "adapter": {
+    "adapter_config_sha256": "a17d24feae695bb21f1635d865f41ecc0e65f3b9e05f8a5e8e8ad5deb97535be",
+    "adapter_model_sha256": "2b2521cff2a98afdd42e3051c8c6de60ad928b1268244f2c13b4193059c6e1f4",
+    "adapter_tensor_digest": "f0e421ca7439a84b50f840d34dea59454c4cc389215101a79ae35c38d0309a00",
+    "default_path": "adapter",
+    "distribution": "bundled_sanitized_adapter"
+  },
+  "admission": {
+    "accepted_modes": [
+      "atomic",
+      "numeric101_text",
+      "numeric101_image",
+      "finite_joint"
+    ],
+    "default_max_input_tokens": 262144,
+    "note": "Operational default, not a model context-length claim. Requests over the configured limit fail without truncation."
+  },
+  "assets": {
+    "base_files": "assets/base_files.sha256.json",
+    "base_files_sha256": "c163d38c5dcd10d307ec81f5b4709b8ec154ef3640d2197bdd1bba3ce27e5993",
+    "codebook255": "assets/codebook255.json",
+    "codebook255_sha256": "4e2e52b4baf578c66bc1d9cf713cb9208ebbd44ce4bd09ed55d79f48fc0f67b7"
+  },
+  "base": {
+    "attention": "sdpa",
+    "dtype": "torch.bfloat16",
+    "model_id": "harshatheg/GPC-1",
+    "revision": "base-278124e95f96d21b",
+    "tokenizer_json_sha256": "5f9e4d4901a92b997e463c1f46055088b6cca5ca61a6522d1b9f64c4bb81cb42",
+    "upstream_model_id": "Qwen/Qwen3.5-35B-A3B",
+    "upstream_revision": "59d61f3ce65a6d9863b86d2e96597125219dc754"
+  },
+  "protocol": "gpc1-inference-release-runtime-v1",
+  "served_model_id": "gpc-1",
+  "weight_format": "adapter"
+}

config.json

@@ -0,0 +1,122 @@
+{
+  "architectures": [
+    "Qwen3_5MoeForConditionalGeneration"
+  ],
+  "gpc1_release": {
+    "adapter_path": "adapter",
+    "format_version": 1,
+    "model_path": "model",
+    "runtime_manifest": "assets/runtime_manifest.json",
+    "runtime_sha256": "d6b0407aef04676d26d54c8dabd20de72e3ecb977172ebcd843837e059f60d91"
+  },
+  "image_token_id": 248056,
+  "model_type": "qwen3_5_moe",
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "attn_output_gate": true,
+    "dtype": "bfloat16",
+    "eos_token_id": 248044,
+    "full_attention_interval": 4,
+    "head_dim": 256,
+    "hidden_act": "silu",
+    "hidden_size": 2048,
+    "initializer_range": 0.02,
+    "layer_types": [
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention"
+    ],
+    "linear_conv_kernel_dim": 4,
+    "linear_key_head_dim": 128,
+    "linear_num_key_heads": 16,
+    "linear_num_value_heads": 32,
+    "linear_value_head_dim": 128,
+    "mamba_ssm_dtype": "float32",
+    "max_position_embeddings": 262144,
+    "mlp_only_layers": [],
+    "model_type": "qwen3_5_moe_text",
+    "moe_intermediate_size": 512,
+    "mtp_num_hidden_layers": 1,
+    "mtp_use_dedicated_embeddings": false,
+    "num_attention_heads": 16,
+    "num_experts": 256,
+    "num_experts_per_tok": 8,
+    "num_hidden_layers": 40,
+    "num_key_value_heads": 2,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "mrope_interleaved": true,
+      "mrope_section": [
+        11,
+        11,
+        10
+      ],
+      "partial_rotary_factor": 0.25,
+      "rope_theta": 10000000,
+      "rope_type": "default"
+    },
+    "router_aux_loss_coef": 0.001,
+    "shared_expert_intermediate_size": 512,
+    "use_cache": true,
+    "vocab_size": 248320
+  },
+  "tie_word_embeddings": false,
+  "transformers_version": "4.57.0.dev0",
+  "video_token_id": 248057,
+  "vision_config": {
+    "deepstack_visual_indexes": [],
+    "depth": 27,
+    "hidden_act": "gelu_pytorch_tanh",
+    "hidden_size": 1152,
+    "in_channels": 3,
+    "initializer_range": 0.02,
+    "intermediate_size": 4304,
+    "model_type": "qwen3_5_moe",
+    "num_heads": 16,
+    "num_position_embeddings": 2304,
+    "out_hidden_size": 2048,
+    "patch_size": 16,
+    "spatial_merge_size": 2,
+    "temporal_patch_size": 2
+  },
+  "vision_end_token_id": 248054,
+  "vision_start_token_id": 248053
+}

demo/README.md

@@ -0,0 +1,49 @@
+---
+title: GPC-1
+emoji: ◈
+colorFrom: gray
+colorTo: green
+sdk: gradio
+sdk_version: 6.9.0
+python_version: '3.12'
+app_file: app.py
+models:
+  - harshatheg/GPC-1
+short_description: Context in. Structured predictions out.
+license: apache-2.0
+header: mini
+---
+
+# GPC-1 demo
+
+Upload context, define your output, and select **Run**. Presets cover classification, numerical analysis, boxes, pose, pixel art, and structured decisions.
+
+## Hosted demo: ZeroGPU
+
+The [hosted demo](https://huggingface.co/spaces/harshatheg/GPC-1-Demo) loads GPC-1 directly on Hugging Face ZeroGPU. No separate inference server is needed. To host that version yourself, duplicate the Space, select ZeroGPU hardware, and add an `HF_TOKEN` secret with read access if the model requires it.
+
+## Server-backed demo
+
+This directory contains a lightweight UI for an existing GPC-1 NVIDIA server. Start the server using the [setup guide](../README.md#get-started), then run these commands from the release directory:
+
+```bash
+cd demo
+python -m pip install -r requirements.txt
+export GPC1_API_URL=http://127.0.0.1:8000
+export GPC1_API_KEY=YOUR_SERVER_KEY
+python app.py
+```
+
+### Host the server-backed UI on Spaces
+
+Copy this directory to a Gradio Space. Configure `GPC1_API_URL` as the HTTPS origin of your NVIDIA server and `GPC1_API_KEY` as a **Space secret**. The lightweight UI calls the server; it does not load model weights on the Space CPU.
+
+The key stays server-side. Requests are not retried automatically. Uploaded context is sent only to the configured model endpoint; temporary uploads are periodically removed. Images are accepted for numeric outputs. Numeric fields use finite-resolution ranges; JSON records select from the records supplied.
+
+## Input limits
+
+The UI accepts up to 256 KiB of context text and a 4 MiB request body. The hosted ZeroGPU version also limits compiled inputs to 8,192 tokens. Use the server API directly for larger inputs; see [context configuration](../API.md#context-window) for its 262,144-token ceiling and hardware requirements.
+
+[Model and API](https://huggingface.co/harshatheg/GPC-1)
+
+The person photo used by the bounding-box and pose presets is [“Tim running” by Liber4l](https://commons.wikimedia.org/wiki/File:Tim_running.jpg), public domain.

demo/app.py

@@ -0,0 +1,150 @@
+import json
+import os
+from pathlib import Path
+
+import gradio as gr
+from PIL import Image, ImageDraw
+from client import MODES, build_request, infer
+from presets import preset
+
+CSS = """
+body, .gradio-container { background: #fff !important; color-scheme: light; }
+.gradio-container { max-width: 1160px !important; padding: 36px 24px !important; }
+#heading h1 { font-size: 32px; font-weight: 650; letter-spacing: -1.1px; margin-bottom: 4px; }
+#heading p { color: #677078; font-size: 15px; }
+#main { gap: 32px; margin-top: 24px; }
+#run { min-height: 46px; border-radius: 10px; }
+button:active { transform: scale(.96); }
+button:focus-visible, input:focus-visible, textarea:focus-visible { outline: 2px solid #147f85; outline-offset: 2px; }
+#timing { color: #677078; font-size: 12px; min-height: 18px; }
+.image-container { outline: 1px solid rgb(0 0 0 / .1); }
+.gradio-container .cm-editor, .gradio-container .cm-content,
+.gradio-container .cm-gutters { background: #f8fafb !important; color: #17252b !important; }
+.gradio-container .cm-content span { color: #17252b !important; }
+.gradio-container .cm-gutters { color: #52616b !important; }
+.gradio-container .cm-cursor { border-left-color: #17252b !important; }
+.gradio-container .cm-selectionBackground { background: #cce8ea !important; }
+.gradio-container .cm-activeLine, .gradio-container .cm-activeLineGutter { background: #edf3f4 !important; }
+.gradio-container .icon-button { color: #52616b !important; }
+.gradio-container button[aria-label="Paste from clipboard"] { color: #52616b !important; }
+.gradio-container button { transition-property: background-color, color, border-color; transition-duration: 120ms; }
+@media(max-width: 650px) { #heading, #main { margin-inline: -24px; width: calc(100% + 48px); } #main { gap: 24px; } }
+@media(prefers-reduced-motion: reduce) { button:active { transform: none; } }
+"""
+LIGHT_JS = """() => { document.documentElement.classList.remove('dark'); document.body.classList.remove('dark'); }"""
+
+def visual_result(image, result, details):
+    fields=details.get('fields',{})
+    means={k:v['expected_value'] for k,v in fields.items()}
+    if image is not None:
+        output=image.convert('RGB').copy(); draw=ImageDraw.Draw(output); w,h=output.size
+        annotated=False
+        if {'x_min','y_min','x_max','y_max'} <= set(means):
+            box=[means[k] for k in ('x_min','y_min','x_max','y_max')]
+            if all(0<=v<=1 for v in box) and box[0]<box[2] and box[1]<box[3]:
+                draw.rectangle((box[0]*w,box[1]*h,box[2]*w,box[3]*h),outline='#008f95',width=max(2,w//180))
+                annotated=True
+        for key,x in means.items():
+            if key.endswith('_x') and key[:-2]+'_y' in means:
+                y=means[key[:-2]+'_y']; r=max(3,w//100)
+                if 0<=x<=1 and 0<=y<=1:
+                    draw.ellipse((x*w-r,y*h-r,x*w+r,y*h+r), fill='#f56538',outline='white',width=2)
+                    annotated=True
+        return output if annotated else None
+    keys=[f'p{r}_{c}' for r in range(5) for c in range(5)]
+    if set(result)==set(keys):
+        palette=['#ffffff','#238454','#ef625c','#f3bd43']
+        out=Image.new('RGB',(5,5),'white')
+        for r in range(5):
+            for c in range(5):
+                value=result[f'p{r}_{c}']
+                out.putpixel((c,r),tuple(bytes.fromhex(palette[max(0,min(3,round(value)))][1:])))
+        return out.resize((400,400),Image.Resampling.NEAREST)
+    return None
+
+def run(context, image, mode, definition, context_file, infer_function=None):
+    try:
+        payload=build_request(context,image,mode,definition,context_file)
+        result,details,elapsed=(infer_function or infer)(payload)
+        picture=visual_result(image,result,details)
+        summaries={k:{'most_likely':v['map_value'],'mean':v['expected_value']} for k,v in details.get('fields',{}).items()}
+        timing_label='Model execution' if infer_function else 'API round trip'
+        return result,gr.update(value=picture,visible=True if picture is not None else 'hidden'),f'{elapsed:.2f} s · {timing_label}',summaries or details,details
+    except (ValueError, RuntimeError) as error:
+        raise gr.Error(str(error)) from None
+
+def select_preset(name):
+    mode,context,definition=preset(name)
+    picture=Path(__file__).parent/'assets/person.jpg'
+    image=str(picture) if name in {'Bounding box','Human pose'} and picture.exists() else None
+    return mode,context,definition,image,None,None,gr.update(value=None,visible='hidden'),'',None,None,gr.update(open=image is not None)
+
+def mode_default(mode):
+    names={'Categories':'Support routing','Numeric ranges':'Numerical analysis','JSON records':'Workflow decision'}
+    return preset(names[mode])[2]
+
+def clear_output():
+    return None, gr.update(value=None,visible='hidden'), '', None, None
+
+def create_demo(infer_function=None):
+    mode,context,definition=preset('Support routing')
+    with gr.Blocks(title='GPC-1',analytics_enabled=False,delete_cache=(600,600)) as demo:
+        gr.Markdown('# GPC-1\nContext in. Structured predictions out.',elem_id='heading')
+        with gr.Row(elem_id='main'):
+            with gr.Column(scale=1,min_width=300):
+                examples=gr.Dropdown(['Support routing','Numerical analysis','Bounding box','Human pose','Pixel art','Workflow decision'],value='Support routing',label='Try an example',filterable=False)
+                text=gr.Textbox(value=context,label='Context',placeholder='Describe the task and add your context…',lines=5,max_lines=12)
+                with gr.Accordion('Add an image or text file',open=False) as attachments:
+                    image=gr.Image(type='pil',sources=['upload','clipboard'],label='Image · numeric ranges',height=220,format='png')
+                    file=gr.File(file_types=['.txt','.md','.json'],file_count='single',label='Context file',type='filepath')
+                mode_input=gr.Radio(MODES,value=mode,label='Output type')
+                fields=gr.Code(value=definition,language='json',label='Define your JSON output',lines=9,max_lines=16,interactive=True)
+                button=gr.Button('Run',variant='primary',elem_id='run')
+            with gr.Column(scale=1,min_width=300):
+                result=gr.JSON(label='Output',value=None)
+                timing=gr.Markdown('',elem_id='timing')
+                picture=gr.Image(label='Visualization',visible='hidden',interactive=False,type='pil',format='png')
+                with gr.Accordion('Scores',open=False):
+                    summaries=gr.JSON(label='Summary')
+                    gr.Markdown('Numeric overlays use probability-weighted means. Pixel art rounds the most likely value to the nearest palette entry. [Score interpretation](https://huggingface.co/harshatheg/GPC-1/blob/main/API.md#interpreting-scores).')
+                    details=gr.JSON(label='Full distributions')
+        mode_input.input(mode_default,inputs=mode_input,outputs=fields,queue=False)
+        examples.input(select_preset,inputs=examples,outputs=[mode_input,text,fields,image,file,result,picture,timing,summaries,details,attachments],queue=False)
+        for component in (text,image,mode_input,fields):
+            component.input(clear_output,outputs=[result,picture,timing,summaries,details],queue=False)
+        file.change(clear_output,outputs=[result,picture,timing,summaries,details],queue=False)
+        from functools import partial
+        runner=partial(run,infer_function=infer_function) if infer_function else run
+        button.click(runner,inputs=[text,image,mode_input,fields,file],outputs=[result,picture,timing,summaries,details],concurrency_limit=1,api_name='predict')
+    return demo.queue(max_size=8,default_concurrency_limit=1)
+
+def light_theme():
+    theme=gr.themes.Base(primary_hue='teal',neutral_hue='gray',font=['Inter','system-ui','sans-serif']).set(
+        background_fill_primary='#ffffff', background_fill_secondary='#f8fafb',
+        body_background_fill='#ffffff', body_text_color='#17252b', body_text_color_subdued='#52616b',
+        block_background_fill='#ffffff', block_label_background_fill='#ffffff',
+        block_label_text_color='#52616b', block_title_text_color='#52616b',
+        input_background_fill='#f8fafb', input_placeholder_color='#52616b',
+        input_border_color='#a7b2b9', input_border_width='1px', input_border_color_focus='#147f85',
+        button_primary_background_fill='#147f85', button_primary_background_fill_hover='#106970',
+        button_primary_border_color='#147f85', button_primary_border_color_hover='#106970',
+        button_primary_text_color='#ffffff', button_primary_text_color_hover='#ffffff',
+        button_secondary_background_fill='#f0f4f5', button_secondary_background_fill_hover='#e3eaed',
+        button_secondary_text_color='#17252b', button_secondary_text_color_hover='#17252b',
+        checkbox_label_background_fill='#f0f4f5', checkbox_label_background_fill_selected='#deeff0',
+        checkbox_label_text_color='#17252b', checkbox_label_text_color_selected='#114e53',
+        checkbox_background_color_selected='#147f85', checkbox_border_color_selected='#147f85',
+        checkbox_border_color='#87969f', checkbox_border_color_hover='#52616b',
+        color_accent='#147f85', code_background_fill='#f8fafb')
+    # Gradio may inherit dark mode from the host page. Keep every token paired.
+    tokens=theme.to_dict()['theme']
+    return theme.set(background_fill_primary=tokens['background_fill_primary'],
+        background_fill_secondary=tokens['background_fill_secondary'],
+        **{key:tokens[key[:-5]] for key in tokens if key.endswith('_dark') and key[:-5] in tokens})
+
+def launch_demo(infer_function=None,blocked_paths=None):
+    create_demo(infer_function).launch(server_name=os.getenv('GRADIO_SERVER_NAME','127.0.0.1'),server_port=int(os.getenv('PORT','7860')),
+        theme=light_theme(),css=CSS,js=LIGHT_JS,show_error=False,max_file_size='3mb',footer_links=[],blocked_paths=blocked_paths)
+
+if __name__=='__main__':
+    launch_demo()

demo/client.py

@@ -0,0 +1,166 @@
+"""Build typed requests and call a configured GPC-1 server."""
+import base64
+from io import BytesIO
+import json
+import math
+import os
+from pathlib import Path
+import time
+from urllib.parse import urlsplit
+
+import httpx
+
+MODES = ('Categories', 'Numeric ranges', 'JSON records')
+MAX_TEXT_BYTES = 256 * 1024
+MAX_IMAGE_BYTES = 3 * 1024 * 1024
+
+def parse_json(value):
+    if not isinstance(value, str): raise ValueError('Define the output as JSON.')
+    def reject(value): raise ValueError('Use finite JSON numbers.')
+    def pairs(items):
+        result = {}
+        for key, item in items:
+            if key in result: raise ValueError('JSON keys must be unique.')
+            result[key] = item
+        return result
+    if len(value.encode()) > 64 * 1024: raise ValueError('Output definition is too large.')
+    try: return json.loads(value, parse_constant=reject, object_pairs_hook=pairs)
+    except json.JSONDecodeError as error: raise ValueError(f'Check JSON at line {error.lineno}.') from None
+    except RecursionError: raise ValueError('Output definition is too deeply nested.') from None
+
+def key_name(key):
+    if not isinstance(key, str) or not key.strip() or key != key.strip() or len(key) > 64:
+        raise ValueError('Use a nonempty JSON key of up to 64 characters.')
+    return key
+
+def value_type(value):
+    if value is None: return 'null'
+    if isinstance(value, bool): return 'boolean'
+    if isinstance(value, str): return 'string'
+    if isinstance(value, (int, float)) and math.isfinite(value): return 'number'
+    raise ValueError('Record values must be strings, finite numbers, booleans, or null.')
+
+def enum_schema(values):
+    types = {value_type(x) for x in values}
+    if len(types) != 1: raise ValueError('Use the same value type for each key.')
+    unique = list({json.dumps(x, sort_keys=True): x for x in values}.values())
+    return {'type': types.pop(), 'enum': unique}
+
+def build_request(context, image, mode, definition, context_file=None):
+    if mode not in MODES: raise ValueError('Choose an output type.')
+    if context is None: context = ''
+    if not isinstance(context, str): raise ValueError('Enter text for the context.')
+    if context_file:
+        try: path = Path(context_file)
+        except TypeError: raise ValueError('Upload a text file.') from None
+        if path.suffix.lower() not in {'.txt', '.md', '.json'}:
+            raise ValueError('Upload a UTF-8 text, Markdown, or JSON file.')
+        try:
+            if path.stat().st_size > MAX_TEXT_BYTES: raise ValueError('Context file exceeds 256 KiB.')
+            uploaded = path.read_text(encoding='utf-8')
+        except UnicodeError: raise ValueError('Context file must contain UTF-8 text.') from None
+        except OSError: raise ValueError('Cannot read the context file. Upload it again.') from None
+        context = context + '\n\n' + uploaded
+    if not context.strip(): raise ValueError('Add context or upload a text file.')
+    if len(context.encode()) > MAX_TEXT_BYTES: raise ValueError('Context exceeds 256 KiB. Nothing was truncated.')
+    definition = parse_json(definition)
+    properties = {}
+    if mode == 'Categories':
+        if not isinstance(definition, dict) or len(definition) != 1:
+            raise ValueError('Define one key with a list of choices, such as {"intent": ["sales", "support"]}.')
+        key, choices = next(iter(definition.items())); key_name(key)
+        if not isinstance(choices, list) or not 2 <= len(choices) <= 255:
+            raise ValueError('Supply 2 to 255 choices.')
+        properties[key] = enum_schema(choices)
+        if len(properties[key]['enum']) != len(choices): raise ValueError('Choices must be unique.')
+        options = dict(mode='atomic', field_key=key, choices=choices)
+    elif mode == 'Numeric ranges':
+        if not isinstance(definition, list) or not 1 <= len(definition) <= 128:
+            raise ValueError('Supply 1 to 128 field definitions.')
+        fields = []
+        for field in definition:
+            if not isinstance(field, dict) or set(field) != {'key','description','minimum','maximum','unit'}:
+                raise ValueError('Each field needs key, description, minimum, maximum, and unit.')
+            key = key_name(field['key'])
+            if key in properties: raise ValueError('Field keys must be unique.')
+            for name in ('description', 'unit'):
+                if not isinstance(field[name], str) or not field[name].strip() or field[name] != field[name].strip():
+                    raise ValueError('Add a description and unit without surrounding whitespace.')
+            low, high = field['minimum'], field['maximum']
+            if any(isinstance(x, bool) or not isinstance(x,(int,float)) or not math.isfinite(x) for x in (low,high)) or low >= high:
+                raise ValueError('Minimum and maximum must be finite numbers, with minimum below maximum.')
+            fields.append(field)
+            properties[key] = dict(type='number', minimum=low, maximum=high)
+        options = dict(mode='numeric101', numeric_fields=fields)
+    else:
+        if not isinstance(definition, list) or not 2 <= len(definition) <= 32 or any(not isinstance(x,dict) or not x for x in definition):
+            raise ValueError('Supply 2 to 32 complete JSON records.')
+        if len({json.dumps(x,sort_keys=True) for x in definition}) != len(definition): raise ValueError('Records must be unique.')
+        keys = list(definition[0])
+        if any(set(x) != set(keys) for x in definition): raise ValueError('Every record must have the same keys.')
+        for key in keys:
+            key_name(key); properties[key] = enum_schema([x[key] for x in definition])
+        options = dict(mode='finite_joint', allowed_records=definition)
+    content = context
+    if image is not None:
+        if mode != 'Numeric ranges': raise ValueError('Images support Numeric ranges. Choose that type or remove the image.')
+        from PIL import Image
+        if not isinstance(image, Image.Image): raise ValueError('Upload a valid image.')
+        if image.width*image.height > 16777216: raise ValueError('Image exceeds 16 megapixels. Resize before uploading.')
+        try:
+            buffer = BytesIO(); image.convert('RGB').save(buffer, format='PNG')
+        except (OSError, ValueError): raise ValueError('Cannot read the image. Upload it again.') from None
+        if buffer.tell() > MAX_IMAGE_BYTES: raise ValueError('Encoded image exceeds 3 MiB. Resize before uploading.')
+        uri = 'data:image/png;base64,' + base64.b64encode(buffer.getvalue()).decode()
+        content = [dict(type='text', text=context), dict(type='image_url', image_url=dict(url=uri))]
+    payload = dict(model='gpc-1', messages=[dict(role='user', content=content)],
+        response_format=dict(type='json_schema', json_schema=dict(name='result',strict=True,
+            schema=dict(type='object',properties=properties,required=list(properties),additionalProperties=False))),
+        gpc1=options, stream=False)
+    if len(json.dumps(payload).encode()) > 4*1024*1024: raise ValueError('Request exceeds 4 MiB. Nothing was truncated.')
+    return payload
+
+def infer(payload):
+    endpoint = os.getenv('GPC1_API_URL','').rstrip('/')
+    token = os.getenv('GPC1_API_KEY','')
+    parsed = urlsplit(endpoint)
+    if not token or not parsed.hostname or parsed.username or parsed.password or parsed.query or parsed.fragment:
+        raise RuntimeError('The model endpoint is not configured.')
+    if parsed.scheme != 'https' and not (parsed.scheme=='http' and parsed.hostname in {'localhost','127.0.0.1','::1'}):
+        raise RuntimeError('The model endpoint requires HTTPS.')
+    started = time.perf_counter()
+    try:
+        with httpx.Client(timeout=httpx.Timeout(180, connect=10), follow_redirects=False, trust_env=False) as client:
+            response = client.post(endpoint+'/v1/chat/completions', json=payload,
+                                   headers={'Authorization': 'Bearer '+token})
+    except httpx.TimeoutException: raise RuntimeError('The request timed out. It was not retried.') from None
+    except httpx.HTTPError: raise RuntimeError('Cannot reach the model. Try again later.') from None
+    if response.status_code == 429: raise RuntimeError('The model is busy. Try again shortly.')
+    if response.status_code == 413: raise ValueError('The request is too large. Reduce context or image size.')
+    if response.status_code != 200: raise RuntimeError('The model could not process this request. Check the field definitions and context length.')
+    try:
+        data=response.json(); result=json.loads(data['choices'][0]['message']['content'])
+        details=data['gpc1']
+        if not isinstance(result, dict) or not isinstance(details, dict): raise ValueError
+        expected=set(payload['response_format']['json_schema']['schema']['properties'])
+        if set(result) != expected: raise ValueError
+        if payload['gpc1']['mode']=='atomic':
+            value=json.dumps(result[payload['gpc1']['field_key']],sort_keys=True,allow_nan=False)
+            if value not in {json.dumps(x,sort_keys=True,allow_nan=False) for x in payload['gpc1']['choices']}: raise ValueError
+        elif payload['gpc1']['mode']=='finite_joint':
+            value=json.dumps(result,sort_keys=True,allow_nan=False)
+            if value not in {json.dumps(x,sort_keys=True,allow_nan=False) for x in payload['gpc1']['allowed_records']}: raise ValueError
+        else:
+            fields=details.get('fields')
+            if not isinstance(fields, dict) or set(fields) != expected: raise ValueError
+            for key, value in result.items():
+                field=fields[key]
+                if (isinstance(value,bool) or not isinstance(value,(int,float)) or not math.isfinite(value)
+                    or not isinstance(field,dict) or any(isinstance(field.get(k),bool) or not isinstance(field.get(k),(int,float)) or not math.isfinite(field[k]) for k in ('map_value','expected_value'))):
+                    raise ValueError
+                bounds=payload['response_format']['json_schema']['schema']['properties'][key]
+                if value != field['map_value'] or not bounds['minimum'] <= value <= bounds['maximum'] or not bounds['minimum'] <= field['expected_value'] <= bounds['maximum']:
+                    raise ValueError
+    except (ValueError, KeyError, IndexError, TypeError): raise RuntimeError('The model returned an invalid response.') from None
+    elapsed=time.perf_counter()-started
+    return result, details, elapsed

demo/presets.py

@@ -0,0 +1,23 @@
+import json
+
+def field(key, description, minimum=0, maximum=1, unit='image fraction'):
+    return dict(key=key, description=description, minimum=minimum, maximum=maximum, unit=unit)
+
+PRESETS = {
+    'Support routing': ('Categories', 'I was charged twice for my subscription this month. Please refund the duplicate payment.',
+        {'intent': ['billing', 'technical_support', 'sales', 'cancellation']}),
+    'Numerical analysis': ('Numeric ranges', 'A tank holds 200 liters. It is 35% full. Return its current volume in liters.',
+        [field('volume', 'Current volume of liquid in the tank', 0, 200, 'liters')]),
+    'Bounding box': ('Numeric ranges', 'Locate the runner in the red shirt. Return their full visible body bounding box. Origin is top-left; x increases right and y increases down. All coordinates are normalized from 0 to 1.',
+        [field(k, d) for k,d in zip(['x_min','y_min','x_max','y_max'],['Left edge of runner in red','Top edge of runner in red','Right edge of runner in red','Bottom edge of runner in red'])]),
+    'Human pose': ('Numeric ranges', 'Locate the runner in the red shirt\'s nose and left wrist (the runner\'s left, not the viewer\'s). Return visible landmark coordinates normalized to 0–1. Origin is top-left, x increases right and y down.',
+        [field(k, d) for k,d in zip(['nose_x','nose_y','left_wrist_x','left_wrist_y'],['Runner nose horizontal coordinate','Runner nose vertical coordinate','Runner left wrist horizontal coordinate','Runner left wrist vertical coordinate'])]),
+    'Pixel art': ('Numeric ranges', 'Draw a recognizable flower on a 5 by 5 pixel grid. Each key is row_column, zero-indexed from top-left. Pixel codes: 0=white background, 1=green stem or leaf, 2=red petals, 3=yellow center. Use a cohesive shape with one stem and a centered blossom.',
+        [field(f'p{r}_{c}',f'Pixel at row {r}, column {c}',0,3,'palette index') for r in range(5) for c in range(5)]),
+    'Workflow decision': ('JSON records', 'The customer reports a duplicate subscription charge and requests a refund. Select the appropriate team and action.',
+        [{'team':'billing','action':'review_refund'}, {'team':'support','action':'troubleshoot'}, {'team':'sales','action':'contact_customer'}]),
+}
+
+def preset(name):
+    mode,context,definition=PRESETS[name]
+    return mode, context, json.dumps(definition,indent=2,ensure_ascii=False)

demo/requirements.txt

@@ -0,0 +1,3 @@
+gradio==6.9.0
+httpx==0.28.1
+Pillow==12.3.0

docs/ARCHITECTURE.md

@@ -0,0 +1,34 @@
+# Architecture
+
+GPC-1 uses the Qwen3.5-35B-A3B multimodal mixture-of-experts architecture with schema-bound inference. You define the output space; the server scores it and returns typed values.
+
+## Model package
+
+`model/` contains GPC-1's modified backbone weights; `adapter/` contains the matching adapter applied at load time. Use both components from the same release. Qwen identifies the upstream architecture; the packaged weights belong to GPC-1.
+
+The server loads the backbone in BF16 and the adapter in FP32. It uses the existing language-model output projection to score the request's allowed outputs.
+
+| Mode | Output |
+| --- | --- |
+| Categorical | A selected label and probabilities over your choices |
+| Numeric | A grid estimate, probability-weighted mean, and distribution per field |
+| Image numeric | Numeric fields conditioned on one image |
+| Finite joint | A selected complete record and probabilities over allowed records |
+
+## Numeric ranges
+
+For bounds `[minimum, maximum]`, the 101-point grid is:
+
+`value(i) = minimum + (maximum - minimum) × i / 100`
+
+Numeric fields share one model pass. Each returns a marginal distribution; shared context does not make them a full joint distribution. The probability-weighted mean can fall between grid positions. Angles and other circular quantities need application-specific interpretation.
+
+## Dependent records
+
+Finite-joint mode scores complete records rather than choosing their fields independently. Probabilities are conditional on the supplied records. Compute and memory grow with the number and length of candidates.
+
+## Serving
+
+The runtime verifies packaged asset identities, uses request-local execution, and rejects over-limit inputs without truncation. Its input ceiling is 256K tokens (262,144), including compiled request overhead. See [context configuration](../API.md#context-window) for deployment requirements. Preserve the supplied precision, prompt formatting, and token mapping when reproducing outputs. Scale concurrent traffic with separate replicas.
+
+See the [API guide](../API.md) for request formats and limits.

docs/DATA_AND_LICENSES.md

@@ -0,0 +1,50 @@
+# Third-party notices
+
+The following notices preserve applicable attribution. They do not grant additional rights to third-party material.
+
+## Code and base model
+
+- **GPC-1 inference code:** Apache-2.0.
+- **Qwen3.5-35B-A3B:** the pinned upstream revision `59d61f3ce65a6d9863b86d2e96597125219dc754` is published under Apache-2.0. Preserve its upstream license, copyright, patent, trademark, and attribution notices.
+
+The GPC-1 code license does not replace the terms of the base model, adapter artifacts, source material, or dependencies.
+
+## Material source notices
+
+- **CLINC OOS:** CC-BY-3.0; preserve the Larson et al. source attribution and license notice.
+- **UCI SMS Spam Collection:** CC-BY-4.0; Almeida, T. and Hidalgo, J. (2011), *SMS Spam Collection*, UCI Machine Learning Repository, DOI `10.24432/C5CC84`.
+- **HelpSteer2:** CC-BY-4.0 at revision `990b2711a36180dd19d9c94b8627844866f8982a`.
+- **Example photograph:** Liber4l, [Tim running](https://commons.wikimedia.org/wiki/File:Tim_running.jpg), public domain. The bounding-box illustration adds the model's predicted coordinates and presentation layout. No endorsement is implied.
+- **Pose illustration photograph:** [Misty / sub_lime79](https://www.flickr.com/photos/16932921@N08/4668205945/), [CC BY 2.0](https://creativecommons.org/licenses/by/2.0/), with a point overlay. No endorsement is implied.
+- **Intent illustration text:** [Larson et al., CLINC OOS](https://github.com/clinc/oos-eval), [CC BY 3.0](https://creativecommons.org/licenses/by/3.0/).
+- **CMU motion capture:** retain CMU attribution and NSF EIA-0196217 funding acknowledgment. CMU's published permission does not permit direct resale of the data or converted data. No capture data are distributed here.
+- **GLiClass logic, Typed Decisions, OpenBookQA adaptation, and TruthfulQA MC1 adaptation:** preserve their recorded Apache-2.0 notices; retain the OpenBookQA transport repository's MIT notice.
+- **Google Civil Comments and public Open-Jev:** CC0-1.0. Open-Jev revision: `c67699e13d0ae25e35b77165a4b6b079bedc8aba`.
+- **CFPB Consumer Complaint Database:** official public-use source. This project does not recast that public-use statement as an SPDX license.
+- **U.S. Census Bureau:** 2024 American Community Survey 5-year Summary File, tract estimates. U.S. federal government public-domain material; source credit retained.
+- **Material UI:** MIT, copyright (c) 2014 Call-Em-All. The notice below applies to the upstream component declarations.
+- **PushT:** `lerobot/pusht`, revision `7628202a2180972f291ba1bc6723834921e72c19`, published under MIT. No source images or action records are distributed here.
+
+Source-specific rights and restrictions remain applicable independently of the GPC-1 code license.
+
+## Material UI license
+
+Copyright (c) 2014 Call-Em-All
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

docs/DOWNLOADS.md

@@ -0,0 +1,60 @@
+# Download GPC-1
+
+Download the complete GPC-1 release: the GPC-1 backbone in `model/`, its matching adapter in `adapter/`, and the serving package. Keep both weight components and release metadata together; the server loads them automatically.
+
+## Command line
+
+```bash
+python -m pip install "huggingface-hub>=1.7,<2"
+hf download harshatheg/GPC-1 --local-dir gpc-1
+python gpc-1/download.py verify gpc-1
+```
+
+For a reproducible deployment, pin a commit SHA and use the same revision in every environment:
+
+```bash
+hf download harshatheg/GPC-1 --revision YOUR_COMMIT_SHA --local-dir gpc-1
+python gpc-1/download.py verify gpc-1
+```
+
+Private or gated access uses `HF_TOKEN` in the environment. Keep the token in your secret manager; do not put it in command arguments or logs.
+
+## Python
+
+If you already have `download.py` from the release package, run Python from its directory:
+
+```python
+from pathlib import Path
+from download import fetch
+
+package = fetch(
+    "harshatheg/GPC-1",
+    revision="YOUR_COMMIT_SHA",
+    local_dir=Path("gpc-1"),
+    cache_dir=None,
+    offline=False,
+)
+print(package["model"])
+```
+
+`fetch` uses `huggingface_hub.snapshot_download` for the complete repository. Verification checks that the root and packaged base configs match, all inventoried base files and indexed weight shards are present, and the runtime manifest, base metadata, and adapter hashes match. It does not hash every base weight shard; the server checks those hashes when it loads the model. No tracking endpoint is called.
+
+## Cache and offline use
+
+After an online download, verify a copied package without contacting the Hub:
+
+```bash
+python gpc-1/download.py verify gpc-1
+```
+
+For offline deployment, download the complete package with `--local-dir` while online, then copy that directory to the offline machine. Run the verification command above on the copied directory. Verification makes no Hub request. Use the materialized package directory, not a cache snapshot containing symlinks.
+
+## CI
+
+Pin the revision in your pipeline and keep the token in a CI secret. A complete package can then be mounted read-only by the serving process:
+
+```bash
+hf download harshatheg/GPC-1 --revision "$GPC1_REVISION" --local-dir gpc-1
+python gpc-1/download.py verify gpc-1
+export GPC1_MODEL_PATH="$PWD/gpc-1/model"
+```

docs/HUB_METRICS.md

@@ -0,0 +1,11 @@
+# Hub metrics for maintainers
+
+Read the repository's download counts without fetching model weights:
+
+```bash
+python gpc-1/download.py counts
+```
+
+The command reads Hub metadata and reports `downloads` and, when available, `downloads_all_time`. It sends no tracking event.
+
+[Hugging Face counts requests for query files](https://huggingface.co/docs/hub/models-download-stats); `config.json` is the default query file. Complete downloads through the CLI, Python, or CI normally request it. Counts are not unique users or verified installations. Offline copies and weights-only transfers may not be counted.

download.py

@@ -0,0 +1,181 @@
+"""Fetch and verify the complete GPC-1 release with the standard Hub client."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import sys
+from pathlib import Path, PurePosixPath
+
+DEFAULT_REPO = "harshatheg/GPC-1"
+SHA256 = re.compile(r"^[0-9a-f]{64}$")
+
+
+def _release_path(root: Path, value: object, *, directory: bool) -> Path:
+    if not isinstance(value, str) or not value:
+        raise ValueError("Release metadata contains an empty path")
+    if "\\" in value or any(part in ("", ".", "..") for part in value.split("/")):
+        raise ValueError(f"Invalid release path: {value}")
+    relative = PurePosixPath(value)
+    if relative.is_absolute():
+        raise ValueError(f"Invalid release path: {value}")
+    path = root.joinpath(*relative.parts)
+    if not path.resolve().is_relative_to(root.resolve()):
+        raise ValueError(f"Release path escapes package: {value}")
+    if directory and not path.is_dir():
+        raise ValueError(f"Missing release directory: {value}")
+    if not directory and not path.is_file():
+        raise ValueError(f"Missing release file: {value}")
+    return path
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def verify_package(root: Path) -> dict[str, str]:
+    """Validate metadata, adapter hashes, and the complete listed base-file set."""
+    root = root.resolve()
+    config_file = root / "config.json"
+    if not config_file.is_file() or config_file.is_symlink():
+        raise ValueError("Missing root config.json; fetch the full model repository")
+    config = json.loads(config_file.read_text(encoding="utf-8"))
+    if not isinstance(config, dict) or not config.get("model_type"):
+        raise ValueError("Root config.json is not a model config")
+    release = config.get("gpc1_release")
+    if not isinstance(release, dict) or release.get("format_version") != 1:
+        raise ValueError("Root config.json lacks supported gpc1_release metadata")
+    model = _release_path(root, release.get("model_path"), directory=True)
+    adapter = _release_path(root, release.get("adapter_path"), directory=True)
+    manifest_file = _release_path(root, release.get("runtime_manifest"), directory=False)
+    if model == adapter or model == root or adapter == root:
+        raise ValueError("Release model and adapter paths must be distinct package directories")
+    expected = release.get("runtime_sha256")
+    if not isinstance(expected, str) or not SHA256.fullmatch(expected):
+        raise ValueError("Invalid runtime_sha256 in release metadata")
+    actual = _sha256_file(manifest_file)
+    if actual != expected:
+        raise ValueError("Runtime manifest checksum mismatch")
+    model_config_file = model / "config.json"
+    if not model_config_file.is_file():
+        raise ValueError("Missing model/config.json")
+    model_config = json.loads(model_config_file.read_text(encoding="utf-8"))
+    root_base_config = dict(config)
+    root_base_config.pop("gpc1_release")
+    if root_base_config != model_config:
+        raise ValueError("Root model config does not match packaged base config")
+    manifest = json.loads(manifest_file.read_text(encoding="utf-8"))
+    if not isinstance(manifest, dict) or manifest.get("served_model_id") != "gpc-1":
+        raise ValueError("Runtime manifest is not for GPC-1")
+    assets = manifest.get("assets", {})
+    inventory_file = _release_path(root, assets.get("base_files"), directory=False)
+    if _sha256_file(inventory_file) != assets.get("base_files_sha256"):
+        raise ValueError("Base-file inventory checksum mismatch")
+    inventory = json.loads(inventory_file.read_text(encoding="utf-8"))
+    if (inventory.get("model_id") != manifest.get("base", {}).get("model_id")
+            or inventory.get("revision") != manifest.get("base", {}).get("revision")):
+        raise ValueError("Base-file inventory identity mismatch")
+    files = inventory.get("files")
+    if not isinstance(files, dict) or not files:
+        raise ValueError("Base-file inventory is empty")
+    for name, digest in files.items():
+        if not isinstance(digest, str) or not SHA256.fullmatch(digest):
+            raise ValueError("Invalid base-file inventory digest")
+        path = _release_path(model, name, directory=False)
+        if path.stat().st_size == 0:
+            raise ValueError(f"Empty base file: {name}")
+        if name in ("config.json", "model.safetensors.index.json") and _sha256_file(path) != digest:
+            raise ValueError(f"Base file checksum mismatch: {name}")
+    index_file = model / "model.safetensors.index.json"
+    if "model.safetensors.index.json" not in files or not index_file.is_file():
+        raise ValueError("Missing model shard index")
+    index = json.loads(index_file.read_text(encoding="utf-8"))
+    shards = set(index.get("weight_map", {}).values())
+    if not shards or not shards.issubset(files.keys()) or any(not isinstance(s, str) or not s.endswith(".safetensors") for s in shards):
+        raise ValueError("Model shard index does not match base-file inventory")
+    adapter_manifest = manifest.get("adapter", {})
+    for name, key in (("adapter_config.json", "adapter_config_sha256"),
+                      ("adapter_model.safetensors", "adapter_model_sha256")):
+        path = _release_path(adapter, name, directory=False)
+        if _sha256_file(path) != adapter_manifest.get(key):
+            raise ValueError(f"Adapter file checksum mismatch: {name}")
+    return {"root": str(root), "model": str(model), "adapter": str(adapter), "runtime_sha256": actual}
+
+
+def fetch(repo: str, revision: str | None, local_dir: Path | None, cache_dir: Path | None, offline: bool) -> dict[str, str]:
+    try:
+        from huggingface_hub import snapshot_download
+    except ImportError as exc:
+        raise RuntimeError("Install huggingface-hub to fetch the package") from exc
+
+    try:
+        path = snapshot_download(
+            repo_id=repo,
+            repo_type="model",
+            revision=revision,
+            local_dir=str(local_dir) if local_dir else None,
+            cache_dir=str(cache_dir) if cache_dir else None,
+            local_files_only=offline,
+            token=os.environ.get("HF_TOKEN") or None,
+        )
+    except Exception:
+        raise RuntimeError("Hub fetch failed; check access, revision, cache, and connectivity") from None
+    return verify_package(Path(path))
+
+
+def counts(repo: str) -> dict[str, object]:
+    """Read a Hub model-info snapshot; never fetch query files for analytics."""
+    try:
+        from huggingface_hub import HfApi
+    except ImportError as exc:
+        raise RuntimeError("Install huggingface-hub to read counts") from exc
+
+    try:
+        info = HfApi(token=os.environ.get("HF_TOKEN") or None).model_info(
+            repo_id=repo, expand=["downloads", "downloadsAllTime"]
+        )
+    except Exception:
+        raise RuntimeError("Hub model-info request failed; check access and connectivity") from None
+    return {
+        "repo": repo,
+        "downloads_30d": getattr(info, "downloads", None),
+        "downloads_all_time": getattr(info, "downloads_all_time", None),
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    fetch_parser = sub.add_parser("fetch", help="Download the full model package and verify its release metadata")
+    fetch_parser.add_argument("--repo", default=DEFAULT_REPO)
+    fetch_parser.add_argument("--revision", help="Pin a tag or, preferably, a commit SHA")
+    fetch_parser.add_argument("--local-dir", type=Path)
+    fetch_parser.add_argument("--cache-dir", type=Path)
+    fetch_parser.add_argument("--offline", action="store_true", help="Use cached files only; no Hub request")
+    verify_parser = sub.add_parser("verify", help="Verify a package already on disk without network access")
+    verify_parser.add_argument("path", type=Path)
+    count_parser = sub.add_parser("counts", help="Read current Hub download counts")
+    count_parser.add_argument("--repo", default=DEFAULT_REPO)
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "fetch":
+            result = fetch(args.repo, args.revision, args.local_dir, args.cache_dir, args.offline)
+        elif args.command == "verify":
+            result = verify_package(args.path)
+        else:
+            result = counts(args.repo)
+    except (OSError, ValueError, RuntimeError) as exc:
+        parser.exit(1, f"{args.command}: {exc}\n")
+    print(json.dumps(result, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

examples/atomic_request.json

@@ -0,0 +1 @@
+{"model":"gpc-1","messages":[{"role":"user","content":"Is the invoice approved? The record says approved."}],"response_format":{"type":"json_schema","json_schema":{"name":"decision","strict":true,"schema":{"type":"object","properties":{"label":{"type":"string","enum":["approved","rejected"]}},"required":["label"],"additionalProperties":false}}},"gpc1":{"mode":"atomic","field_key":"label","choices":["approved","rejected"]},"stream":false}

examples/numeric_request.json

@@ -0,0 +1,7 @@
+{
+  "model": "gpc-1",
+  "messages": [{"role": "user", "content": "A 200 cm rail is filled to 75%. Report filled length."}],
+  "response_format": {"type": "json_schema", "json_schema": {"name": "rail", "strict": true, "schema": {"type": "object", "properties": {"filled_length": {"type": "number", "minimum": 0, "maximum": 200}}, "required": ["filled_length"], "additionalProperties": false}}},
+  "gpc1": {"mode": "numeric101", "numeric_fields": [{"key": "filled_length", "description": "filled rail length", "minimum": 0, "maximum": 200, "unit": "cm"}]},
+  "stream": false
+}

gpc1_server/__init__.py

@@ -0,0 +1,3 @@
+"""GPC-1 inference-only OpenAI-style serving package."""
+
+__version__ = "0.1.0"

gpc1_server/api.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import binascii
+from contextlib import asynccontextmanager
+from io import BytesIO
+import json
+import math
+import os
+import secrets
+import time
+import uuid
+from typing import Any
+
+from fastapi import FastAPI, Header, Request
+from fastapi.responses import JSONResponse
+from PIL import Image
+from pydantic import ValidationError
+from jsonschema import Draft202012Validator
+
+from .compiler import NumericField
+from .errors import APIError
+from .runtime import Backend, TransformersBackend
+from .schemas import ChatRequest
+
+MAX_BODY_BYTES = int(os.getenv("GPC1_MAX_BODY_BYTES", str(16 * 1024 * 1024)))
+MAX_IMAGE_BYTES = int(os.getenv("GPC1_MAX_IMAGE_BYTES", str(3 * 1024 * 1024)))
+MAX_IMAGE_PIXELS = int(os.getenv("GPC1_MAX_IMAGE_PIXELS", "16777216"))
+Image.MAX_IMAGE_PIXELS = MAX_IMAGE_PIXELS
+MAX_QUEUE_WAIT_SECONDS = float(os.getenv("GPC1_MAX_QUEUE_WAIT_SECONDS", "2"))
+SUPPORTED_SCHEMA_KEYS = {"type", "properties", "required", "additionalProperties", "description",
+                         "enum", "items", "minimum", "maximum"}
+
+
+def error_response(error: APIError, request_id: str | None = None) -> JSONResponse:
+    headers = {"x-request-id": request_id} if request_id else {}
+    if error.status_code == 429:
+        headers["Retry-After"] = "1"
+    return JSONResponse(error.body(), status_code=error.status_code, headers=headers)
+
+
+def validate_schema(schema: Any, path: str = "response_format.json_schema.schema", depth: int = 0) -> None:
+    if depth > 16: raise APIError("JSON Schema nesting exceeds 16",param=path)
+    if not isinstance(schema, dict):
+        raise APIError("JSON Schema must be an object", param=path)
+    unknown = set(schema) - SUPPORTED_SCHEMA_KEYS
+    if unknown:
+        raise APIError(f"unsupported JSON Schema keywords: {sorted(unknown)}", param=path)
+    def finite(value: Any) -> bool:
+        if isinstance(value,float): return math.isfinite(value)
+        if isinstance(value,dict): return all(finite(k) and finite(v) for k,v in value.items())
+        if isinstance(value,list): return all(finite(v) for v in value)
+        return True
+    if not finite(schema):
+        raise APIError("JSON Schema contains a non-finite number", param=path)
+    kind = schema.get("type")
+    if not isinstance(kind, str) or kind not in {"object", "array", "string", "number", "integer", "boolean", "null"}:
+        raise APIError("schema type must be one supported explicit type", param=f"{path}.type")
+    if kind == "object":
+        properties = schema.get("properties")
+        required = schema.get("required")
+        if not isinstance(properties, dict) or not isinstance(required, list):
+            raise APIError("objects require properties and required", param=path)
+        if any(not isinstance(v, str) for v in required) or len(required) != len(set(required)):
+            raise APIError("required must contain unique property-name strings", param=f"{path}.required")
+        if set(required) != set(properties) or schema.get("additionalProperties") is not False:
+            raise APIError("strict objects require every property and additionalProperties=false", param=path)
+        for name, child in properties.items(): validate_schema(child, f"{path}.properties.{name}",depth+1)
+    if kind == "array":
+        validate_schema(schema.get("items"), f"{path}.items",depth+1)
+
+
+def validate_instance(value: Any, schema: dict[str, Any], path: str = "output") -> None:
+    def finite(v: Any) -> bool:
+        if isinstance(v, float): return math.isfinite(v)
+        if isinstance(v, dict): return all(finite(k) and finite(x) for k, x in v.items())
+        if isinstance(v, list): return all(finite(x) for x in v)
+        return True
+    if not finite(value): raise APIError(f"{path} contains a non-finite number", param="gpc1")
+    errors=sorted(Draft202012Validator(schema).iter_errors(value),key=lambda e:list(e.path))
+    if errors: raise APIError(f"{path} violates schema: {errors[0].message}",param="gpc1")
+
+
+def _decode_image(url: str) -> Image.Image:
+    if not url.startswith("data:image/"):
+        raise APIError("only inline data:image URIs are accepted; remote URLs are disabled",
+                       param="messages.content.image_url.url", code="remote_image_disabled")
+    try:
+        header, encoded = url.split(",", 1)
+        media = header[5:].split(";", 1)[0].lower()
+        if header != f"data:{media};base64" or media not in {"image/png", "image/jpeg", "image/webp"}:
+            raise ValueError
+        raw = base64.b64decode(encoded, validate=True)
+    except (ValueError, binascii.Error) as error:
+        raise APIError("invalid base64 image data URI", param="messages.content.image_url.url") from error
+    if len(raw) > MAX_IMAGE_BYTES:
+        raise APIError("decoded image exceeds byte limit", status_code=413, code="image_too_large")
+    try:
+        image = Image.open(BytesIO(raw))
+        if image.width * image.height > MAX_IMAGE_PIXELS:
+            raise APIError("decoded image exceeds pixel limit", status_code=413, code="image_too_large")
+        image.verify()
+        image = Image.open(BytesIO(raw)).convert("RGB")
+    except APIError:
+        raise
+    except Exception as error:
+        raise APIError("image payload failed safe decode", param="messages.content.image_url.url") from error
+    return image
+
+
+def flatten_messages(messages: list[Any]) -> tuple[str, Image.Image | None]:
+    texts=[]; image=None
+    for message in messages:
+        if isinstance(message.content, str):
+            texts.append(f"{message.role.upper()}: {message.content}")
+            continue
+        for part in message.content:
+            if set(part) == {"type", "text"} and part["type"] == "text" and isinstance(part["text"], str):
+                texts.append(f"{message.role.upper()}: {part['text']}")
+            elif set(part) == {"type", "image_url"} and part["type"] == "image_url" \
+                    and isinstance(part["image_url"], dict) and set(part["image_url"]) <= {"url", "detail"}:
+                if image is not None:
+                    raise APIError("at most one image is supported", param="messages")
+                image = _decode_image(str(part["image_url"].get("url", "")))
+            else:
+                raise APIError("unsupported message content part", param="messages.content")
+    context="\n".join(texts)
+    if not context.strip(): raise APIError("messages must include text context", param="messages")
+    return context, image
+
+
+def create_app(backend: Backend | None = None) -> FastAPI:
+    selected = backend
+    if int(os.getenv("GPC1_MAX_CONCURRENCY", "1")) != 1:
+        raise RuntimeError("canonical request-local runtime requires GPC1_MAX_CONCURRENCY=1")
+    max_pending = int(os.getenv("GPC1_MAX_PENDING_REQUESTS", "4"))
+    if max_pending < 0:
+        raise RuntimeError("GPC1_MAX_PENDING_REQUESTS must be nonnegative")
+    if not math.isfinite(MAX_QUEUE_WAIT_SECONDS) or MAX_QUEUE_WAIT_SECONDS <= 0:
+        raise RuntimeError("GPC1_MAX_QUEUE_WAIT_SECONDS must be finite and positive")
+    semaphore = asyncio.Semaphore(1)
+    admitted = 0
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        nonlocal selected
+        if selected is None:
+            if not os.getenv("GPC1_API_KEY"): raise RuntimeError("GPC1_API_KEY is required")
+            selected = TransformersBackend()
+        yield
+
+    app = FastAPI(title="GPC-1 OpenAI-style API", version="0.1.0", lifespan=lifespan)
+
+    async def run_native(call, *args):
+        task=asyncio.create_task(asyncio.to_thread(call,*args))
+        try: return await asyncio.shield(task)
+        except asyncio.CancelledError:
+            # Retain the model lease until the worker thread finishes.
+            while not task.done():
+                try:
+                    await asyncio.shield(task)
+                except asyncio.CancelledError:
+                    continue
+                except Exception:
+                    break
+            if not task.cancelled():
+                task.exception()
+            raise
+
+    @app.exception_handler(APIError)
+    async def api_error_handler(_: Request, error: APIError): return error_response(error)
+
+    @app.middleware("http")
+    async def admission(request: Request, call_next):
+        request_id = "req_" + uuid.uuid4().hex
+        if request.method == "POST" and "content-length" not in request.headers:
+            return error_response(APIError("Content-Length is required", 411, code="length_required"), request_id)
+        try: content_length = int(request.headers.get("content-length", "0") or 0)
+        except ValueError: return error_response(APIError("invalid Content-Length", 400), request_id)
+        if content_length < 0 or content_length > MAX_BODY_BYTES:
+            return error_response(APIError("request body exceeds byte limit", 413, code="request_too_large"), request_id)
+        configured = os.getenv("GPC1_API_KEY")
+        supplied = request.headers.get("authorization", "")
+        if request.url.path not in {"/healthz", "/readyz"} and configured and not secrets.compare_digest(supplied, f"Bearer {configured}"):
+            return error_response(APIError("invalid API key", 401, "authentication_error", code="invalid_api_key"), request_id)
+        response = await call_next(request); response.headers["x-request-id"] = request_id; return response
+
+    @app.get("/healthz", include_in_schema=False)
+    async def health():
+        return {"status": "ok"}
+
+    @app.get("/readyz", include_in_schema=False)
+    async def ready():
+        if selected is None:
+            return JSONResponse({"status": "not_ready"}, status_code=503)
+        return {"status": "ready"}
+
+    @app.get("/v1/models")
+    async def models():
+        assert selected is not None
+        return {"object": "list", "data": [{"id": selected.model_id, "object": "model",
+                "created": 0, "owned_by": "gpc-1"}]}
+
+    @app.post("/v1/chat/completions")
+    async def completions(request: Request):
+        nonlocal admitted
+        if admitted >= 1 + max_pending:
+            raise APIError("server is at capacity; retry with backoff", 429, "rate_limit_error", code="server_busy")
+        admitted += 1
+        try:
+            try:
+                await asyncio.wait_for(semaphore.acquire(), timeout=MAX_QUEUE_WAIT_SECONDS)
+            except TimeoutError as error:
+                raise APIError("server is at capacity; retry with backoff", 429, "rate_limit_error", code="server_busy") from error
+            try:
+                return await complete_admitted(request)
+            finally:
+                semaphore.release()
+        finally:
+            admitted -= 1
+
+    async def complete_admitted(request: Request):
+        assert selected is not None
+        try:
+            chunks=[]; actual=0
+            async for chunk in request.stream():
+                actual += len(chunk)
+                if actual > MAX_BODY_BYTES: raise APIError("request body exceeds byte limit",413,code="request_too_large")
+                chunks.append(chunk)
+            raw=await asyncio.to_thread(json.loads, b"".join(chunks),
+                                        parse_constant=lambda value: (_ for _ in ()).throw(
+                                            ValueError("JSON contains a non-finite number; use finite numeric values")))
+            parsed = await asyncio.to_thread(ChatRequest.model_validate, raw)
+        except (json.JSONDecodeError, UnicodeDecodeError, ValueError, ValidationError) as error:
+            raise APIError(str(error), param="body") from error
+        if parsed.model != selected.model_id:
+            raise APIError(f"model {parsed.model!r} not found", 404, "invalid_request_error", "model", "model_not_found")
+        wrapper = parsed.response_format.json_schema
+        if wrapper.get("strict") is not True or not isinstance(wrapper.get("name"), str) or set(wrapper) != {"name", "strict", "schema"}:
+            raise APIError("json_schema requires exactly name, strict=true, and schema", param="response_format.json_schema")
+        await asyncio.to_thread(validate_schema, wrapper["schema"])
+        try: await asyncio.to_thread(Draft202012Validator.check_schema, wrapper["schema"])
+        except Exception as error: raise APIError(f"invalid JSON Schema: {error}",param="response_format.json_schema.schema") from error
+        context, image = await asyncio.to_thread(flatten_messages, parsed.messages)
+        if parsed.temperature is not None or parsed.max_completion_tokens is not None:
+            raise APIError("temperature and max_completion_tokens are unsupported; omit them",param="temperature")
+        try:
+            if parsed.gpc1.mode == "atomic":
+                if image is not None: raise APIError("atomic image mode is not supported",param="messages")
+                choices=parsed.gpc1.choices or []
+                try:
+                    for choice in choices: json.dumps(choice,allow_nan=False)
+                except (TypeError,ValueError) as error: raise APIError("atomic choices must be finite JSON",param="gpc1.choices") from error
+                field_key=str(parsed.gpc1.field_key)
+                schema=wrapper["schema"]
+                properties=schema.get("properties",{})
+                if set(properties)!={field_key} or properties[field_key].get("enum") != choices:
+                    raise APIError("atomic field and choices must exactly match the schema enum",param="gpc1")
+                result=await run_native(selected.atomic,context,field_key,choices)
+                value={field_key:result["value"]}
+            elif parsed.gpc1.mode == "numeric101":
+                raw_fields = parsed.gpc1.numeric_fields or []
+                if not 1 <= len(raw_fields) <= 512:
+                    raise APIError("numeric101 requires 1..512 fields", param="gpc1.numeric_fields")
+                expected_field_keys = {"key", "description", "minimum", "maximum", "unit"}
+                optional_field_keys = {"aliases", "reference"}
+                if any(not expected_field_keys <= set(v) or set(v) - expected_field_keys - optional_field_keys for v in raw_fields):
+                    raise APIError("numeric field keys are invalid", param="gpc1.numeric_fields")
+                fields = [NumericField(
+                    key=str(v["key"]), description=str(v["description"]),
+                    minimum=float(v["minimum"]), maximum=float(v["maximum"]), unit=str(v["unit"]),
+                    aliases=tuple(map(str, v.get("aliases", []))), reference=str(v.get("reference", "declared_by_caller")))
+                    for v in raw_fields]
+                if len({field.key for field in fields}) != len(fields):
+                    raise APIError("numeric field keys must be unique", param="gpc1.numeric_fields")
+                names=[name for field in fields for name in (field.key,*field.aliases)]
+                if len(names) != len(set(names)):
+                    raise APIError("numeric canonical keys and aliases must be globally unique",param="gpc1.numeric_fields")
+                properties = wrapper["schema"].get("properties", {})
+                if set(properties) != {field.key for field in fields} or any(
+                    properties[f.key].get("type") != "number"
+                    or properties[f.key].get("minimum") != f.minimum
+                    or properties[f.key].get("maximum") != f.maximum for f in fields):
+                    raise APIError("numeric fields and bounds must exactly match number properties", param="gpc1.numeric_fields")
+                result = await run_native(selected.numeric, context, fields, image)
+                value = {key: field["value"] for key, field in result["fields"].items()}
+            else:
+                if image is not None: raise APIError("finite_joint image mode is not supported", param="messages")
+                records = parsed.gpc1.allowed_records or []
+                if not 2 <= len(records) <= 255: raise APIError("finite_joint requires 2..255 allowed records", param="gpc1.allowed_records")
+                try:
+                    for record in records: json.dumps(record,allow_nan=False)
+                except (TypeError,ValueError) as error: raise APIError("allowed records must be finite JSON",param="gpc1.allowed_records") from error
+                for index, record in enumerate(records):
+                    await asyncio.to_thread(validate_instance, record, wrapper["schema"], f"allowed_records[{index}]")
+                encoded = [json.dumps(v, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False) for v in records]
+                if len(encoded) != len(set(encoded)): raise APIError("allowed records must be unique", param="gpc1.allowed_records")
+                result = await run_native(selected.finite_joint, context, wrapper["schema"], records)
+                value = result["value"]
+            await asyncio.to_thread(validate_instance, value, wrapper["schema"])
+        except APIError: raise
+        except (KeyError, TypeError, ValueError) as error:
+            raise APIError(str(error), param="gpc1") from error
+        content = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        now = int(time.time()); completion_id = "chatcmpl_" + uuid.uuid4().hex
+        return {"id": completion_id, "object": "chat.completion", "created": now,
+                "model": selected.model_id, "choices": [{"index": 0,
+                "message": {"role": "assistant", "content": content}, "finish_reason": "stop", "logprobs": None}],
+                "usage": None,
+                "gpc1": result}
+    return app
+
+
+app = create_app()

gpc1_server/assets.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+ASSET_ROOT = PACKAGE_ROOT / "assets"
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def load_runtime_manifest() -> dict[str, Any]:
+    manifest = json.loads((ASSET_ROOT / "runtime_manifest.json").read_text())
+    codebook = ASSET_ROOT / "codebook255.json"
+    if sha256_file(codebook) != manifest["assets"]["codebook255_sha256"]:
+        raise RuntimeError("frozen codebook hash mismatch")
+    base_files = ASSET_ROOT / "base_files.sha256.json"
+    if sha256_file(base_files) != manifest["assets"]["base_files_sha256"]:
+        raise RuntimeError("frozen base-file manifest hash mismatch")
+    return manifest
+
+
+def load_codebook() -> tuple[dict[str, Any], ...]:
+    manifest = load_runtime_manifest()
+    rows = json.loads((ASSET_ROOT / "codebook255.json").read_text())
+    if len(rows) != 255 or [r["position"] for r in rows] != list(range(255)):
+        raise RuntimeError("frozen codebook must contain positions 0..254")
+    if len({r["code"] for r in rows}) != 255 or len({r["token_id"] for r in rows}) != 255:
+        raise RuntimeError("frozen codebook codes/token IDs are not unique")
+    return tuple(rows)

gpc1_server/bootstrap.py

@@ -0,0 +1,23 @@
+"""Verify or copy the exact model bundled with this release."""
+from __future__ import annotations
+import argparse
+import json
+from pathlib import Path
+import shutil
+from .assets import ASSET_ROOT,sha256_file
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('--output',type=Path,required=True)
+    args=parser.parse_args();source=ASSET_ROOT.parent/'model'
+    inventory=json.loads((ASSET_ROOT/'base_files.sha256.json').read_text())
+    if args.output.resolve()!=source.resolve() and args.output.exists() and any(args.output.iterdir()):
+        raise RuntimeError('--output must be absent or empty')
+    for name,digest in inventory['files'].items():
+        if not (source/name).is_file() or sha256_file(source/name)!=digest:
+            raise RuntimeError(f'Bundled model identity mismatch: {name}')
+    if args.output.resolve()!=source.resolve():
+        args.output.mkdir(parents=True,exist_ok=True)
+        for name in inventory['files']:shutil.copyfile(source/name,args.output/name)
+    print(args.output.resolve())
+
+if __name__=='__main__':main()

gpc1_server/compiler.py

@@ -0,0 +1,205 @@
+"""Compile numeric requests and decode range predictions."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import math
+from typing import Any, Sequence
+
+
+@dataclass(frozen=True, slots=True)
+class NumericField:
+    key: str
+    description: str
+    minimum: float
+    maximum: float
+    unit: str
+    aliases: tuple[str, ...] = ()
+    reference: str = "declared_by_caller"
+
+    def __post_init__(self) -> None:
+        values=(self.key,self.description,self.unit,self.reference,*self.aliases)
+        if any(not isinstance(v,str) or not v.strip() or v != v.strip() for v in values):
+            raise ValueError("numeric names and descriptions must be nonempty and edge-whitespace-free")
+        if self.key in self.aliases or len(self.aliases) != len(set(self.aliases)):
+            raise ValueError("numeric aliases must be unique and exclude the canonical key")
+        if not math.isfinite(self.minimum) or not math.isfinite(self.maximum) or self.minimum >= self.maximum:
+            raise ValueError("numeric bounds must be finite and strictly increasing")
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledNumeric:
+    prompt: str
+    input_ids: tuple[int, ...]
+    positions: tuple[int, ...]
+    candidate_token_ids: tuple[int, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledVisionNumeric:
+    numeric: CompiledNumeric
+    processor_inputs: dict[str, Any]
+    positions: tuple[int, ...]
+
+
+def _query(field: NumericField) -> str:
+    # Preserve formatting for tokenizer compatibility.
+    return ("QUERY canonical_key=" + json.dumps(field.key, ensure_ascii=False)
+            + " unit=" + json.dumps(field.unit, ensure_ascii=False)
+            + f" bounds=[{field.minimum!r},{field.maximum!r}]\nAnswer code:\n")
+
+
+def render_prefix(context: str, fields: Sequence[NumericField], codes: Sequence[str]) -> str:
+    shared_map = [{"transport_code": codes[i], "percentage_index": i,
+                   "normalized_point": i / 100.0} for i in range(101)]
+    definitions = [{"canonical_key": f.key, "aliases": list(f.aliases),
+                    "meaning": f.description, "range": [f.minimum, f.maximum],
+                    "unit": f.unit, "reference": f.reference,
+                    "affine_decode": "value=lower+normalized_point*(upper-lower)"}
+                   for f in fields]
+    return ("NATIVE_NUMERIC_SHARED_CODEBOOK_QUERY_SLOTS_V1\n"
+            "Return exactly one listed opaque transport code for every point field. "
+            "The shared map binds each transport code to one normalized point. "
+            "Each field definition supplies its own affine bounds and unit. Transport strings "
+            "are labels, not pretrained numeric semantics.\n"
+            "All maps and field definitions precede all answer-query slots. "
+            "No answer is present in this input.\nSHARED_TRANSPORT_MAP="
+            + json.dumps(shared_map, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+            + "\nFIELD_DEFINITIONS="
+            + json.dumps(definitions, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+            + "\nCONTEXT_BEGIN\n" + context + "\nCONTEXT_END\nBEGIN_QUERY_SLOTS\n")
+
+
+def compile_numeric(tokenizer: Any, context: str, fields: Sequence[NumericField],
+                    codebook: Sequence[dict[str, Any]], max_input_tokens: int) -> CompiledNumeric:
+    if not context.strip() or not fields:
+        raise ValueError("context and fields must be nonempty")
+    names=[name for field in fields for name in (field.key,*field.aliases)]
+    if len(names) != len(set(names)):
+        raise ValueError("numeric canonical keys and aliases must be globally unique")
+    codes = [str(row["code"]) for row in codebook[:101]]
+    prefix = render_prefix(context, fields, codes)
+    cumulative = prefix
+    previous = tuple(tokenizer.encode(cumulative, add_special_tokens=False))
+    positions: list[int] = []
+    for field in fields:
+        cumulative += _query(field)
+        current = tuple(tokenizer.encode(cumulative, add_special_tokens=False))
+        if len(current) <= len(previous) or current[:len(previous)] != previous:
+            raise ValueError("tokenizer resegmented an earlier query boundary")
+        # Native LM logits at the last prompt token predict the opaque code.
+        positions.append(len(current) - 1)
+        previous = current
+    if len(previous) > max_input_tokens:
+        raise ValueError(f"request needs {len(previous)} tokens; limit is {max_input_tokens}; no truncation performed")
+    return CompiledNumeric(cumulative, previous, tuple(positions),
+                           tuple(int(row["token_id"]) for row in codebook[:101]))
+
+
+def decode_numeric(probabilities: Sequence[float], field: NumericField) -> dict[str, Any]:
+    if len(probabilities) != 101:
+        raise ValueError("numeric probability vector must have 101 entries")
+    total = math.fsum(float(p) for p in probabilities)
+    if not math.isfinite(total) or total <= 0 or any(float(p) < 0 for p in probabilities):
+        raise ValueError("invalid numeric probability vector")
+    probs = [float(p) / total for p in probabilities]
+    map_index = max(range(101), key=probs.__getitem__)
+    expected_index = math.fsum(i * p for i, p in enumerate(probs))
+    span = field.maximum - field.minimum
+    return {
+        "value": field.minimum + span * map_index / 100.0,
+        "map_value": field.minimum + span * map_index / 100.0,
+        "expected_value": field.minimum + span * expected_index / 100.0,
+        "map_index": map_index,
+        "normalized_grid": [i / 100.0 for i in range(101)],
+        "probabilities": probs,
+        "minimum": field.minimum, "maximum": field.maximum, "unit": field.unit,
+        "calibrated": False,
+    }
+
+
+def _unique_subsequence_offset(values: Sequence[int], needle: Sequence[int]) -> int:
+    """Find one token span in linear time, rejecting absent or repeated spans."""
+    if not needle:
+        raise ValueError("target-free numeric prompt must occur exactly once")
+    failure = [0] * len(needle)
+    matched = 0
+    for index in range(1, len(needle)):
+        while matched and needle[index] != needle[matched]:
+            matched = failure[matched - 1]
+        if needle[index] == needle[matched]:
+            matched += 1
+        failure[index] = matched
+    matched = 0
+    offset = -1
+    for index, value in enumerate(values):
+        while matched and value != needle[matched]:
+            matched = failure[matched - 1]
+        if value == needle[matched]:
+            matched += 1
+        if matched == len(needle):
+            if offset >= 0:
+                raise ValueError("target-free numeric prompt must occur exactly once")
+            offset = index + 1 - len(needle)
+            matched = failure[matched - 1]
+    if offset < 0:
+        raise ValueError("target-free numeric prompt must occur exactly once")
+    return offset
+
+
+def compile_vision_numeric(processor: Any, image: Any, context: str,
+                           fields: Sequence[NumericField], codebook: Sequence[dict[str, Any]],
+                           max_input_tokens: int, model_config: Any) -> CompiledVisionNumeric:
+    """Compile one image and numeric fields using the native processor."""
+    import torch
+    width, height = getattr(image, "size", (0, 0))
+    if width <= 0 or height <= 0:
+        raise ValueError("source raster dimensions must be positive")
+    numeric = compile_numeric(processor.tokenizer, context, fields, codebook, max_input_tokens)
+    messages = [[
+        {"role": "user", "content": [
+            {"type": "image", "image": image},
+            {"type": "text", "text": (
+                "Inspect only this supplied full uncropped image. The following assistant "
+                "schema contains target-free coordinate query slots for this image.")}]},
+        {"role": "assistant", "content": [{"type": "text",
+            "text": numeric.prompt + "END_TARGET_FREE_QUERY_BLOCK\n"}]},
+    ]]
+    batch = processor.apply_chat_template(messages, tokenize=True, truncation=False,
+        add_generation_prompt=False, continue_final_message=False, enable_thinking=False,
+        return_dict=True, return_tensors="pt", return_mm_token_type_ids=True)
+    tensors = {k: v for k, v in batch.items() if isinstance(v, torch.Tensor)}
+    required = {"input_ids", "attention_mask", "pixel_values", "image_grid_thw", "mm_token_type_ids"}
+    if set(tensors) != required:
+        raise ValueError(f"processor tensor keys must be exactly {sorted(required)}, got {sorted(tensors)}")
+    ids, mask, mm = tensors["input_ids"], tensors["attention_mask"], tensors["mm_token_type_ids"]
+    if ids.ndim != 2 or ids.shape[0] != 1 or mask.shape != ids.shape or mm.shape != ids.shape:
+        raise ValueError("vision request requires aligned singleton text tensors")
+    if not bool(mask.eq(1).all()) or ids.shape[1] + 1 > max_input_tokens:
+        raise ValueError("vision request exceeds token admission or contains padding; no truncation performed")
+    grid = tensors["image_grid_thw"]
+    if grid.shape != (1, 3) or not bool((grid > 0).all()):
+        raise ValueError("image_grid_thw must be one positive [t,h,w] row")
+    patch_rows = int(grid.prod().item())
+    if tensors["pixel_values"].ndim != 2 or tensors["pixel_values"].shape[0] != patch_rows:
+        raise ValueError("pixel_values and processor grid disagree")
+    config = model_config.to_dict() if hasattr(model_config, "to_dict") else dict(model_config)
+    if config.get("model_type") != "qwen3_5_moe" or not isinstance(config.get("vision_config"), dict):
+        raise ValueError("vision compiler requires the pinned multimodal Qwen3.5 MoE config")
+    merge = int(processor.image_processor.merge_size)
+    if patch_rows % (merge * merge): raise ValueError("image grid is not divisible by merge area")
+    image_token = int(config["image_token_id"])
+    active = [int(v) for v in ids[0].tolist()]
+    expected_image_tokens = patch_rows // (merge * merge)
+    if active.count(image_token) != expected_image_tokens:
+        raise ValueError("image token count and processor grid disagree")
+    vision_start = int(config["vision_start_token_id"]); vision_end = int(config["vision_end_token_id"])
+    if active.count(vision_start) != 1 or active.count(vision_end) != 1:
+        raise ValueError("vision boundary token count is not exactly one pair")
+    mm_values = [int(v) for v in mm[0].tolist()]
+    if any((kind == 1) != (token == image_token) for token, kind in zip(active, mm_values, strict=True)):
+        raise ValueError("image tokens and mm_token_type_ids disagree")
+    needle = numeric.input_ids
+    offset = _unique_subsequence_offset(active, needle)
+    positions = tuple(offset + p for p in numeric.positions)
+    return CompiledVisionNumeric(numeric, tensors, positions)

gpc1_server/errors.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class APIError(Exception):
+    message: str
+    status_code: int = 400
+    error_type: str = "invalid_request_error"
+    param: str | None = None
+    code: str | None = None
+
+    def body(self) -> dict:
+        return {"error": {"message": self.message, "type": self.error_type,
+                          "param": self.param, "code": self.code}}

gpc1_server/native_onepass.py

@@ -0,0 +1,122 @@
+"""Score complete candidate records in one model call."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Sequence
+
+import torch
+
+
+@dataclass(frozen=True, slots=True)
+class Row:
+    index: int
+    candidate_id: str
+    targets: tuple[int, ...]
+    positions: tuple[int, ...]
+    prefix_tokens: int
+    input_tokens: int
+
+
+@dataclass(frozen=True, slots=True)
+class CompiledJoint:
+    input_ids: torch.Tensor
+    attention_mask: torch.Tensor
+    position_ids: torch.Tensor
+    logits_to_keep: torch.Tensor
+    rows: tuple[Row, ...]
+    candidate_order: tuple[str, ...]
+    padded_tokens: int
+    logit_vectors: int
+
+
+def _contains(values: tuple[int, ...], needle: tuple[int, ...]) -> bool:
+    return len(needle) <= len(values) and any(
+        values[i:i + len(needle)] == needle for i in range(len(values) - len(needle) + 1)
+    )
+
+
+def compile_joint(prefix: Sequence[int], candidate_ids: Sequence[str],
+                  suffixes: Sequence[Sequence[int]], terminal: Sequence[int], *,
+                  pad_token_id: int, max_rows: int, max_padded_tokens: int,
+                  max_logit_vectors: int, max_input_tokens: int) -> CompiledJoint:
+    prefix = tuple(prefix); terminal = tuple(terminal)
+    ids = tuple(candidate_ids); suffixes = tuple(tuple(v) for v in suffixes)
+    if not prefix or not terminal or any(type(v) is not int or v < 0 for v in prefix + terminal):
+        raise ValueError("prefix and terminal must contain nonnegative token IDs")
+    if not ids or len(ids) != len(set(ids)) or any(not isinstance(v, str) or not v for v in ids):
+        raise ValueError("candidate IDs must be unique nonempty strings")
+    if len(ids) != len(suffixes) or len(suffixes) != len(set(suffixes)):
+        raise ValueError("candidate suffixes must be unique and align with candidate IDs")
+    if any(prefix[-n:] == terminal[:n] for n in range(1, min(len(prefix), len(terminal)) + 1)):
+        raise ValueError("prefix overlaps the declared terminal boundary")
+    for suffix in suffixes:
+        if (len(suffix) < len(terminal) or suffix[-len(terminal):] != terminal
+                or _contains(suffix[:-len(terminal)], terminal)):
+            raise ValueError("every candidate must contain the common terminal exactly at its end")
+    for i, left in enumerate(suffixes):
+        for j, right in enumerate(suffixes):
+            if i != j and len(left) < len(right) and right[:len(left)] == left:
+                raise ValueError("candidate tokenizations prefix-overlap")
+    if any(any(type(v) is not int or v < 0 for v in suffix) for suffix in suffixes):
+        raise ValueError("candidate suffixes must contain nonnegative token IDs")
+    if len(suffixes) > max_rows:
+        raise ValueError(f"compiled rows {len(suffixes)} exceed max_rows {max_rows}")
+    sequences = tuple(prefix + suffix for suffix in suffixes)
+    if max(map(len,sequences)) > max_input_tokens:
+        raise ValueError(f"joint request exceeds max_input_tokens {max_input_tokens}; no truncation performed")
+    width = max(map(len, sequences)); padded = len(sequences) * width
+    if padded > max_padded_tokens:
+        raise ValueError(f"compiled padded tokens {padded} exceed max_padded_tokens {max_padded_tokens}")
+    positions = sorted({p for seq in sequences for p in range(len(prefix) - 1, len(seq) - 1)})
+    vectors = len(sequences) * len(positions)
+    if vectors > max_logit_vectors:
+        raise ValueError(f"compiled logit vectors {vectors} exceed max_logit_vectors {max_logit_vectors}")
+    input_ids = torch.full((len(sequences), width), pad_token_id, dtype=torch.long)
+    mask = torch.zeros_like(input_ids)
+    rows = []
+    for i, (candidate_id, suffix, sequence) in enumerate(zip(ids, suffixes, sequences, strict=True)):
+        input_ids[i, :len(sequence)] = torch.tensor(sequence)
+        mask[i, :len(sequence)] = 1
+        rows.append(Row(i, candidate_id, suffix,
+                        tuple(range(len(prefix) - 1, len(sequence) - 1)), len(prefix), len(sequence)))
+    position_ids = mask.cumsum(-1) - 1; position_ids.masked_fill_(mask == 0, 0)
+    return CompiledJoint(input_ids, mask, position_ids, torch.tensor(positions), tuple(rows), ids,
+                         padded, vectors)
+
+
+def score_joint(model_forward: Callable[..., Any], compiled: CompiledJoint, *, device: Any) -> dict[str, Any]:
+    expected_positions = compiled.attention_mask.cumsum(-1) - 1
+    expected_positions.masked_fill_(compiled.attention_mask == 0, 0)
+    if not torch.equal(compiled.position_ids, expected_positions):
+        raise ValueError("compiled position IDs mutated before forward")
+    keep = [int(value) for value in compiled.logits_to_keep.tolist()]
+    with torch.inference_mode():
+        output = model_forward(input_ids=compiled.input_ids.to(device),
+            attention_mask=compiled.attention_mask.to(device),
+            position_ids=compiled.position_ids.to(device), logits_to_keep=keep,
+            use_cache=False, return_dict=True)
+    logits = output.logits
+    if logits.ndim != 3 or tuple(logits.shape[:2]) != (len(compiled.rows), len(keep)):
+        raise ValueError("native sparse logits do not align to compiled joint positions")
+    logits = logits.float()
+    if not bool(torch.isfinite(logits).all()):
+        raise ValueError("model logits contain non-finite values")
+    columns = {int(p): i for i, p in enumerate(compiled.logits_to_keep.tolist())}
+    scores = []
+    for row in compiled.rows:
+        terms = []
+        for position, target in zip(row.positions, row.targets, strict=True):
+            distribution = logits[row.index, columns[position]]
+            if target >= distribution.numel(): raise ValueError("target token is outside vocabulary")
+            terms.append(distribution[target] - torch.logsumexp(distribution, -1))
+        scores.append(torch.stack(terms).sum())
+    scores_t = torch.stack(scores); probs = torch.exp(scores_t - torch.logsumexp(scores_t, 0))
+    selected = int(torch.argmax(scores_t))
+    return {"selected_index": selected, "probabilities": probs.cpu().tolist(),
+            "log_scores": scores_t.cpu().tolist(),
+            "row_map": [{"row_index": r.index, "candidate_id": r.candidate_id,
+                         "prediction_positions": list(r.positions)} for r in compiled.rows],
+            "accounting": {"backbone_calls": 1, "physical_rows": len(compiled.rows),
+                           "padded_tokens": compiled.padded_tokens,
+                           "logit_vectors": compiled.logit_vectors, "truncated": False},
+            "calibrated": False}

gpc1_server/runtime.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+import json
+import hashlib
+import os
+from pathlib import Path
+from typing import Any, Protocol, Sequence
+
+from .assets import load_codebook, load_runtime_manifest, sha256_file
+from .compiler import NumericField, compile_numeric, compile_vision_numeric, decode_numeric
+from .native_onepass import compile_joint, score_joint
+
+
+class Backend(Protocol):
+    model_id: str
+    def numeric(self, context: str, fields: Sequence[NumericField], image: Any | None = None) -> dict[str, Any]: ...
+    def atomic(self, context: str, field_key: str, choices: Sequence[Any]) -> dict[str, Any]: ...
+    def finite_joint(self, context: str, schema: dict[str, Any], candidates: Sequence[dict[str, Any]]) -> dict[str, Any]: ...
+
+
+class TransformersBackend:
+    """Pinned Transformers/PEFT backend; no custom CUDA kernels or generation."""
+
+    @staticmethod
+    def _context_limits(manifest: dict[str, Any], model_config: dict[str, Any],
+                        environ: dict[str, str]) -> tuple[int, int]:
+        capacity = int(model_config["text_config"]["max_position_embeddings"])
+        default = int(manifest["admission"]["default_max_input_tokens"])
+        limit = int(environ.get("GPC1_MAX_INPUT_TOKENS", str(default)))
+        if not 0 < limit <= capacity:
+            raise ValueError(f"GPC1_MAX_INPUT_TOKENS must be between 1 and {capacity}")
+        padded = int(environ.get("GPC1_MAX_PADDED_TOKENS", str(max(131072, 2 * limit))))
+        if padded <= 0:
+            raise ValueError("GPC1_MAX_PADDED_TOKENS must be positive")
+        return limit, padded
+
+    @staticmethod
+    def _verify_model_file_closure(model_path: Path, expected_files: set[str]) -> None:
+        top_files={p.name for p in model_path.iterdir() if p.is_file()}
+        suspicious={name for name in top_files if (
+            name.endswith((".safetensors",".json",".jinja",".txt"))
+            or "config" in name or "tokenizer" in name or "processor" in name or "index" in name)}
+        if suspicious != expected_files:
+            raise RuntimeError(f"loader-visible model file closure mismatch: {sorted(suspicious ^ expected_files)}")
+
+    @staticmethod
+    def _verify_adapter_file_closure(adapter_path: Path) -> None:
+        adapter_files={p.name for p in adapter_path.iterdir() if p.is_file()}
+        if adapter_files != {"adapter_config.json","adapter_model.safetensors"}:
+            raise RuntimeError("adapter directory must contain exactly the two bound release files")
+
+    @staticmethod
+    def _adapter_path(manifest: dict[str, Any], package_root: Path,
+                      environ: dict[str, str]) -> Path:
+        if manifest.get("weight_format") != "adapter" or not isinstance(manifest.get("adapter"), dict) \
+                or manifest.get("merged_full_weights") is not None:
+            raise RuntimeError("release runtime requires adapter weight metadata only")
+        return Path(environ.get("GPC1_ADAPTER_PATH", package_root / "adapter"))
+
+    def __init__(self) -> None:
+        import torch
+        from transformers import AutoProcessor
+        from transformers import Qwen3_5MoeForConditionalGeneration
+
+        self.torch = torch
+        torch.backends.cuda.matmul.allow_tf32 = False
+        torch.backends.cudnn.allow_tf32 = False
+        torch.set_float32_matmul_precision("highest")
+        self.manifest = load_runtime_manifest()
+        package_root = Path(__file__).resolve().parents[1]
+        model_path = Path(os.environ["GPC1_MODEL_PATH"])
+        self.max_input_tokens, self.max_padded_tokens = self._context_limits(
+            self.manifest, json.loads((model_path / "config.json").read_text()), os.environ)
+        adapter_path = self._adapter_path(self.manifest, package_root, os.environ)
+        self._verify_artifacts(model_path, adapter_path)
+        self.processor = AutoProcessor.from_pretrained(model_path, local_files_only=True,
+                                                       trust_remote_code=False)
+        base = Qwen3_5MoeForConditionalGeneration.from_pretrained(
+            model_path, local_files_only=True, trust_remote_code=False,
+            dtype=torch.bfloat16, attn_implementation="sdpa",
+            low_cpu_mem_usage=True, device_map={"": 0})
+        from peft import PeftModel
+        self.model = PeftModel.from_pretrained(base, adapter_path, is_trainable=False,
+                                               autocast_adapter_dtype=True)
+        self.model.eval()
+        for parameter in self.model.parameters():
+            parameter.requires_grad_(False)
+        if base.__class__.__name__ != "Qwen3_5MoeForConditionalGeneration" \
+                or getattr(base.config, "model_type", None) != "qwen3_5_moe":
+            raise RuntimeError("loaded base is not the pinned Qwen3.5 MoE architecture")
+        adapter_parameters = {name: p for name, p in self.model.named_parameters() if "lora_" in name}
+        base_dtypes = {p.dtype for name, p in self.model.named_parameters()
+                       if p.is_floating_point() and "lora_" not in name}
+        if base_dtypes != {torch.bfloat16} or not adapter_parameters \
+                or {p.dtype for p in adapter_parameters.values()} != {torch.float32}:
+            raise RuntimeError("loaded base/adapter dtype inventory differs from BF16/FP32 contract")
+        from peft.utils import get_peft_model_state_dict
+        digest = hashlib.sha256()
+        state = get_peft_model_state_dict(self.model)
+        for name in sorted(state):
+            tensor = state[name].detach().cpu().contiguous()
+            metadata = json.dumps({"dtype":str(tensor.dtype),"name":name,"shape":list(tensor.shape)},
+                                  sort_keys=True,separators=(",", ":")).encode()
+            raw = tensor.view(torch.uint8).numpy().tobytes()
+            digest.update(len(metadata).to_bytes(8,"big")); digest.update(metadata)
+            digest.update(len(raw).to_bytes(8,"big")); digest.update(raw)
+        if digest.hexdigest() != self.manifest["adapter"]["adapter_tensor_digest"]:
+            raise RuntimeError("loaded adapter tensor digest mismatch")
+        self.model_id = self.manifest["served_model_id"]
+        self.codebook = load_codebook()
+        self.max_joint_rows = int(os.environ.get("GPC1_MAX_JOINT_ROWS", "32"))
+        self.max_logit_vectors = int(os.environ.get("GPC1_MAX_LOGIT_VECTORS", "512"))
+        self.max_logits_bytes = int(os.environ.get("GPC1_MAX_LOGITS_BYTES", str(512 * 1024 * 1024)))
+        accepted_modes = set(self.manifest["admission"]["accepted_modes"])
+        self.admit_vision = "numeric101_image" in accepted_modes \
+            and os.environ.get("GPC1_ADMIT_VISION_NUMERIC", "accepted") == "accepted"
+        self.admit_joint = "finite_joint" in accepted_modes \
+            and os.environ.get("GPC1_ADMIT_FINITE_JOINT", "accepted") == "accepted"
+        cache_mb = int(os.environ.get("GPC1_IMAGE_CACHE_MB", "64"))
+        if not 0 <= cache_mb <= 64:
+            raise ValueError("GPC1_IMAGE_CACHE_MB must be an integer between 0 and 64")
+        self._vision_cache = None
+        if cache_mb:
+            from .vision_cache import VisionFeatureCache
+            self._vision_cache = VisionFeatureCache(
+                self.model.base_model.model.model.visual, torch, cache_mb * 1024 * 1024)
+
+    def _verify_artifacts(self, model_path: Path, adapter_path: Path) -> None:
+        expected = self.manifest
+        package_root = Path(__file__).resolve().parents[1]
+        inventory_path = package_root / "assets" / "base_files.sha256.json"
+        inventory = json.loads(inventory_path.read_text())
+        if inventory["model_id"] != expected["base"]["model_id"] or inventory["revision"] != expected["base"]["revision"]:
+            raise RuntimeError("model-file inventory identity mismatch")
+        self._verify_model_file_closure(model_path, set(inventory["files"]))
+        for relative, digest in inventory["files"].items():
+            path = model_path / relative
+            if not path.is_file() or sha256_file(path) != digest:
+                raise RuntimeError(f"pinned model file identity mismatch: {relative}")
+        self._verify_adapter_file_closure(adapter_path)
+        if sha256_file(adapter_path / "adapter_model.safetensors") != expected["adapter"]["adapter_model_sha256"]:
+            raise RuntimeError("bundled adapter identity mismatch")
+        if sha256_file(adapter_path / "adapter_config.json") != expected["adapter"]["adapter_config_sha256"]:
+            raise RuntimeError("bundled adapter config identity mismatch")
+
+    def _forward(self, inputs: dict[str, Any], positions: Sequence[int]) -> Any:
+        torch = self.torch
+        device = next(self.model.parameters()).device
+        moved = {k: v.to(device) if hasattr(v, "to") else v for k, v in inputs.items()}
+        with torch.inference_mode():
+            # Project logits only at requested positions.
+            output = self.model(**moved, logits_to_keep=[int(p) for p in positions],
+                                use_cache=False, return_dict=True)
+        if output.logits.ndim != 3 or tuple(output.logits.shape[:2]) != (1, len(positions)):
+            raise RuntimeError("native sparse logits do not align to query positions")
+        return output.logits[0].float()
+
+    def numeric(self, context: str, fields: Sequence[NumericField], image: Any | None = None) -> dict[str, Any]:
+        vocab = int(self.model.config.text_config.vocab_size)
+        if len(fields) * vocab * 4 > self.max_logits_bytes:
+            raise ValueError("numeric sparse logits exceed byte admission")
+        if image is None:
+            compiled = compile_numeric(self.processor.tokenizer, context, fields, self.codebook,
+                                       self.max_input_tokens)
+            ids = self.torch.tensor([compiled.input_ids], dtype=self.torch.long)
+            mask = self.torch.ones_like(ids)
+            inputs = {"input_ids": ids, "attention_mask": mask,
+                      "position_ids": mask.cumsum(dim=-1) - 1}
+            positions = compiled.positions
+        else:
+            if not self.admit_vision:
+                raise ValueError("vision numeric requires an accepted same-hardware parity gate")
+            vision = compile_vision_numeric(self.processor, image, context, fields, self.codebook,
+                                            self.max_input_tokens, self.model.config)
+            compiled = vision.numeric; inputs = vision.processor_inputs; positions = vision.positions
+        logits = self._forward(inputs, positions)
+        token_ids = self.torch.tensor(compiled.candidate_token_ids, device=logits.device)
+        results = {}
+        for index, field in enumerate(fields):
+            raw = logits[index].index_select(0, token_ids).float()
+            probs = self.torch.softmax(raw, dim=-1).cpu().tolist()
+            results[field.key] = decode_numeric(probs, field)
+        return {"fields": results, "accounting": {"backbone_calls": 1,
+                "physical_rows": 1, "field_slots": len(fields), "truncated": False},
+                "semantics": "per-field marginals; not a learned full joint distribution"}
+
+    def atomic(self, context: str, field_key: str, choices: Sequence[Any]) -> dict[str, Any]:
+        if not 2 <= len(choices) <= 255 or len({json.dumps(v,sort_keys=True) for v in choices}) != len(choices):
+            raise ValueError("atomic choices must contain 2..255 unique JSON values")
+        schema={"field_order":[field_key],"fields":{field_key:{"type":"enum","choices":list(choices)}}}
+        support="\n".join(f'{self.codebook[i]["code"]} = '+json.dumps(v,ensure_ascii=False,sort_keys=True,separators=(",",":")) for i,v in enumerate(choices))
+        user=("Classify the active field from the complete input.\n\nContext:\n"+context+"\n\n"
+              "Registered schema gpc1-public-atomic@1:\n"+json.dumps(schema,ensure_ascii=False,sort_keys=True,separators=(",",":"))
+              +"\n\nAllowed complete outputs in registered semantic order:\n"+support+"\n\nReturn exactly one allowed output.")
+        prompt=self.processor.tokenizer.apply_chat_template([
+            {"role":"system","content":"You are a fixed-schema lookup model. Return exactly one listed opaque code and no other text."},
+            {"role":"user","content":user}],tokenize=False,add_generation_prompt=True,enable_thinking=False)
+        ids=tuple(self.processor.tokenizer.encode(prompt,add_special_tokens=False))
+        if len(ids)>self.max_input_tokens: raise ValueError("atomic request exceeds token admission; no truncation performed")
+        for row in self.codebook[:len(choices)]:
+            combined=tuple(self.processor.tokenizer.encode(prompt+str(row["code"]),add_special_tokens=False))
+            if combined != ids + (int(row["token_id"]),):
+                raise ValueError("atomic response-boundary tokenization changed")
+        tensor=self.torch.tensor([ids]); logits=self._forward({"input_ids":tensor,"attention_mask":self.torch.ones_like(tensor)},[len(ids)-1])[0]
+        indices=self.torch.tensor([int(r["token_id"]) for r in self.codebook[:len(choices)]],device=logits.device)
+        probs=self.torch.softmax(logits.index_select(0,indices).float(),dim=-1).cpu().tolist(); selected=max(range(len(choices)),key=probs.__getitem__)
+        return {"value":choices[selected],"probabilities":probs,"selected_index":selected,"calibrated":False,
+                "accounting":{"backbone_calls":1,"physical_rows":1,"truncated":False},
+                "semantics":"conditional distribution over the complete caller-declared choice set"}
+
+    def finite_joint(self, context: str, schema: dict[str, Any], candidates: Sequence[dict[str, Any]]) -> dict[str, Any]:
+        if not self.admit_joint:
+            raise ValueError("finite_joint requires an accepted same-hardware parity gate")
+        tokenizer = self.processor.tokenizer
+        canonical = [json.dumps(v, ensure_ascii=False, sort_keys=True,
+                                separators=(",", ":"), allow_nan=False) for v in candidates]
+        support = "\n".join(f"{value} = {value}" for value in canonical)
+        user = ("Select one complete allowed JSON record from the complete input.\n\nContext:\n" + context
+                + "\n\nRegistered schema gpc1-public-finite-joint@1:\n"
+                + json.dumps(schema, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False)
+                + "\n\nAllowed complete outputs in registered semantic order:\n" + support
+                + "\n\nReturn exactly one allowed output.")
+        prompt = tokenizer.apply_chat_template([
+            {"role":"system","content":"You are a fixed-schema lookup model. Return exactly one listed complete JSON record and no other text."},
+            {"role":"user","content":user}], tokenize=False, add_generation_prompt=True,
+            enable_thinking=False)
+        prefix = tuple(tokenizer.encode(prompt, add_special_tokens=False))
+        terminal_text = tokenizer.eos_token or "<|im_end|>"
+        terminal = tuple(tokenizer.encode(terminal_text, add_special_tokens=False))
+        suffixes = []
+        for value in canonical:
+            complete = tuple(tokenizer.encode(prompt + value + terminal_text, add_special_tokens=False))
+            if complete[:len(prefix)] != prefix: raise ValueError("candidate tokenization changed prompt prefix")
+            suffixes.append(complete[len(prefix):])
+        compiled = compile_joint(prefix, tuple(str(i) for i in range(len(candidates))), suffixes,
+            terminal, pad_token_id=int(tokenizer.pad_token_id), max_rows=self.max_joint_rows,
+            max_padded_tokens=self.max_padded_tokens, max_logit_vectors=self.max_logit_vectors,
+            max_input_tokens=self.max_input_tokens)
+        vocab = int(self.model.config.text_config.vocab_size)
+        if compiled.logit_vectors * vocab * 4 > self.max_logits_bytes:
+            raise ValueError("joint sparse logits exceed byte admission")
+        device = next(self.model.parameters()).device
+        result = score_joint(self.model, compiled, device=device)
+        result["value"] = candidates[result["selected_index"]]
+        result["semantics"] = "conditional distribution over the complete caller-declared joint support"
+        return result

gpc1_server/schemas.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class Message(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    role: Literal["system", "developer", "user", "assistant"]
+    content: str | list[dict[str, Any]]
+
+
+class ResponseFormat(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    type: Literal["json_schema"]
+    json_schema: dict[str, Any]
+
+
+class GPC1Options(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    mode: Literal["atomic", "numeric101", "finite_joint"]
+    field_key: str | None = None
+    choices: list[Any] | None = None
+    numeric_fields: list[dict[str, Any]] | None = None
+    allowed_records: list[dict[str, Any]] | None = None
+
+    @model_validator(mode="after")
+    def match_mode(self):
+        active = {
+            "atomic": (self.field_key is not None and self.choices is not None,
+                       self.numeric_fields is None and self.allowed_records is None),
+            "numeric101": (self.numeric_fields is not None,
+                           self.field_key is None and self.choices is None and self.allowed_records is None),
+            "finite_joint": (self.allowed_records is not None,
+                             self.field_key is None and self.choices is None and self.numeric_fields is None),
+        }[self.mode]
+        if not all(active):
+            raise ValueError(f"{self.mode} requires only its mode-specific members")
+        return self
+
+
+class ChatRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    model: str
+    messages: list[Message] = Field(min_length=1)
+    response_format: ResponseFormat
+    gpc1: GPC1Options
+    stream: Literal[False] = False
+    temperature: float | None = None
+    max_completion_tokens: int | None = None

gpc1_server/vision_cache.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import hashlib
+import threading
+from typing import Any
+
+
+class VisionFeatureCache:
+    """One-image, memory-bounded cache for a frozen vision encoder."""
+
+    def __init__(self, visual: Any, torch: Any, max_bytes: int = 64 * 1024 * 1024):
+        self.torch = torch
+        self.max_bytes = max_bytes
+        self._key = None
+        self._value = None
+        self._lock = threading.RLock()
+        original = visual.forward
+
+        def forward(*args, **kwargs):
+            if visual.training or torch.is_grad_enabled() or self.max_bytes <= 0:
+                self.clear()
+                return original(*args, **kwargs)
+            with self._lock:
+                key = self._fingerprint((args, kwargs))
+                if key is not None and key == self._key:
+                    return self._clone(self._value)
+                output = original(*args, **kwargs)
+                self._key = self._value = None
+                size = self._size(output)
+                if key is not None and size is not None and size <= self.max_bytes:
+                    self._value = self._clone(output)
+                    self._key = key
+                return output
+
+        visual.forward = forward
+
+    def clear(self):
+        with self._lock:
+            self._key = self._value = None
+
+    def _fingerprint(self, value):
+        torch = self.torch
+        digest = hashlib.sha256()
+
+        def update(item):
+            if isinstance(item, torch.Tensor):
+                if item.layout != torch.strided:
+                    raise TypeError
+                digest.update(repr((str(item.dtype), str(item.device), tuple(item.shape), tuple(item.stride()))).encode())
+                digest.update(item.detach().contiguous().cpu().view(torch.uint8).numpy().tobytes())
+            elif isinstance(item, (tuple, list)):
+                digest.update(type(item).__name__.encode())
+                for child in item:
+                    update(child)
+                    digest.update(b'\0')
+            elif isinstance(item, dict):
+                digest.update(b'dict')
+                for key in sorted(item):
+                    update(key)
+                    update(item[key])
+            elif item is None or type(item) in (bool, int, float, str):
+                digest.update(repr((type(item).__name__, item)).encode())
+            else:
+                raise TypeError
+
+        try:
+            update(value)
+            update((torch.backends.cuda.matmul.allow_tf32, torch.backends.cudnn.allow_tf32,
+                    torch.backends.cudnn.enabled, torch.backends.cudnn.benchmark,
+                    torch.backends.cudnn.deterministic, torch.get_float32_matmul_precision()))
+        except (TypeError, ValueError):
+            return None
+        return digest.digest()
+
+    def _clone(self, value):
+        if isinstance(value, self.torch.Tensor):
+            return value.detach().clone()
+        if isinstance(value, dict):
+            cloned = {k: self._clone(v) for k, v in value.items()}
+            return cloned if type(value) is dict else type(value)(**cloned)
+        if isinstance(value, tuple):
+            return tuple(self._clone(v) for v in value)
+        if isinstance(value, list):
+            return [self._clone(v) for v in value]
+        return value
+
+    def _size(self, value):
+        if isinstance(value, self.torch.Tensor):
+            return value.numel() * value.element_size()
+        if isinstance(value, dict):
+            sizes = [self._size(v) for v in value.values()]
+        elif isinstance(value, (tuple, list)):
+            sizes = [self._size(v) for v in value]
+        elif value is None or type(value) in (bool, int, float, str):
+            return 0
+        else:
+            return None
+        return None if any(v is None for v in sizes) else sum(sizes)

model/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Alibaba Cloud
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

model/chat_template.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

model/config.json

@@ -0,0 +1,115 @@
+{
+    "architectures": [
+        "Qwen3_5MoeForConditionalGeneration"
+    ],
+    "image_token_id": 248056,
+    "model_type": "qwen3_5_moe",
+    "text_config": {
+        "attention_bias": false,
+        "attention_dropout": 0.0,
+        "attn_output_gate": true,
+        "dtype": "bfloat16",
+        "eos_token_id": 248044,
+        "full_attention_interval": 4,
+        "head_dim": 256,
+        "hidden_act": "silu",
+        "hidden_size": 2048,
+        "initializer_range": 0.02,
+        "layer_types": [
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention"
+        ],
+        "linear_conv_kernel_dim": 4,
+        "linear_key_head_dim": 128,
+        "linear_num_key_heads": 16,
+        "linear_num_value_heads": 32,
+        "linear_value_head_dim": 128,
+        "max_position_embeddings": 262144,
+        "mlp_only_layers": [],
+        "model_type": "qwen3_5_moe_text",
+        "moe_intermediate_size": 512,
+        "mtp_num_hidden_layers": 1,
+        "mtp_use_dedicated_embeddings": false,
+        "num_attention_heads": 16,
+        "num_experts": 256,
+        "num_experts_per_tok": 8,
+        "num_hidden_layers": 40,
+        "num_key_value_heads": 2,
+        "rms_norm_eps": 1e-06,
+        "router_aux_loss_coef": 0.001,
+        "shared_expert_intermediate_size": 512,
+        "use_cache": true,
+        "vocab_size": 248320,
+        "mamba_ssm_dtype": "float32",
+        "rope_parameters": {
+            "mrope_interleaved": true,
+            "mrope_section": [
+                11,
+                11,
+                10
+            ],
+            "rope_type": "default",
+            "rope_theta": 10000000,
+            "partial_rotary_factor": 0.25
+        }
+    },
+    "tie_word_embeddings": false,
+    "transformers_version": "4.57.0.dev0",
+    "video_token_id": 248057,
+    "vision_config": {
+        "deepstack_visual_indexes": [],
+        "depth": 27,
+        "hidden_act": "gelu_pytorch_tanh",
+        "hidden_size": 1152,
+        "in_channels": 3,
+        "initializer_range": 0.02,
+        "intermediate_size": 4304,
+        "model_type": "qwen3_5_moe",
+        "num_heads": 16,
+        "num_position_embeddings": 2304,
+        "out_hidden_size": 2048,
+        "patch_size": 16,
+        "spatial_merge_size": 2,
+        "temporal_patch_size": 2
+    },
+    "vision_end_token_id": 248054,
+    "vision_start_token_id": 248053
+}

model/generation_config.json

@@ -0,0 +1,13 @@
+{
+    "bos_token_id": 248044,
+    "do_sample": true,
+    "eos_token_id": [
+        248046,
+        248044
+    ],
+    "pad_token_id": 248044,
+    "temperature": 1.0,
+    "top_k": 20,
+    "top_p": 0.95,
+    "transformers_version": "4.57.0.dev0"
+}

model/model-00001-of-00016.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43a908b3d324d59b66c73a33e5c182809eb2df7da474b2fd2cbdabb16baeee38
+size 4323955448

model/model-00002-of-00016.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4de54e39c2ecc6f3fb5e79e752f84b65c96c316d0d848c9b55d36a062df69e70
+size 4506431768

model/model-00003-of-00016.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:847472ab2e3e10da0baea3993890ce393cc1b364f53674a00a92ac6ed856ec0d
+size 4988775056

model/model-00004-of-00016.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81b2b46905d62b66c6a0d2360050c266ea9416f913708e9a1447b28465f458f0
+size 3962207584