@kindgi/adapter-model-in-process 0.0.0-bootstrap.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 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 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 Kindgi Inc.
+
+   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.

package/README.md

@@ -1,3 +1,70 @@
-# @kindgi/adapter-model-in-process
+# `@kindgi/adapter-model-in-process`
 
-A placeholder. Releases come from https://github.com/kindgi/kindgi-sdk.
+In-process `ModelProvider` for [`@kindgi/capabilities`](../../capabilities/). Runs small instruction-tuned models inside the Node.js process through `@huggingface/transformers` (ONNX runtime): no API key, no external process, no network once the weights are cached, and zero USD cost. Intended as the cheapest routing tier — classification, extraction, routing, smoke tests — not as a replacement for hosted models on reasoning tasks.
+
+## Purpose
+
+Give the capability router a local provider it can match like any other. Every model reports `cost` of `0`, the provider's `region` is `'in-process'`, and `attributes` carry `in-process` plus each model's tier and `suitableFor` hints (`routing`, `classification`, `local`, `lower-cost`, …) for preference matching. `prepareInProcessModel` downloads weights ahead of the first call and streams progress in the `PrepareEvent` shape used by `AdapterFactoryEntry.prepare`.
+
+## Exports
+
+- **`createInProcessModelProvider(options?)`** — returns a `ModelProvider`. Construction is cheap: each model's pipeline loads on the first `invoke()` that names it (concurrent first calls share one load), downloading weights if they are not cached yet. With `@huggingface/transformers` 4.x the default cache is a `.cache` directory inside that package's install location; `cacheDir` redirects the model files (transformers.js 4.3 can still write a model's `config.json` to its default cache). Throws when `models` is empty; `invoke()` throws for a model the provider does not expose.
+  - `invoke()` passes each message to the model's chat template as `{ role, content }`, uses `maxOutputTokens` as `max_new_tokens` (default `512`), samples only when `temperature > 0` (greedy otherwise), and returns `finishReason: 'stop'` and `costUsd: 0`. Token counts come from the model's tokenizer, falling back to about four characters per token. `abortSignal` is not observed.
+- **`InProcessProviderOptions`**:
+  - `models?: readonly LocalModel[]` — models to expose; default `[DEFAULT_LOCAL_MODEL]`.
+  - `providerId?: string` — `metadata.id`; default `in-process/<models joined with '+'>`. Lets the same model set be registered twice under different ids.
+  - `cacheDir?: string` — directory for downloaded model files, passed to transformers.js as `cache_dir`.
+- **`LocalModel`**, **`MODEL_SPECS`**, **`ModelSpec`**, **`DEFAULT_LOCAL_MODEL`** — the closed model set and its per-model spec (`hfName`, `approxDownloadMb`, `contextWindow`, `toolUse`, `tier`, `suitableFor`, `dtype`). All use `q4f16` weights:
+
+  | `LocalModel` | Hugging Face repo | Download | Context | Tier |
+  |---|---|---|---|---|
+  | `smollm2-135m` | `HuggingFaceTB/SmolLM2-135M-Instruct` | ~118 MB | 8,192 | ultra-light |
+  | `smollm2-360m` (default) | `HuggingFaceTB/SmolLM2-360M-Instruct` | ~273 MB | 8,192 | small |
+  | `qwen3-0.6b` | `onnx-community/Qwen3-0.6B-ONNX` | ~550 MB | 32,768 | medium |
+
+- **`prepareInProcessModel(params?)`** / **`PrepareInProcessParams`** — `AsyncIterable<PrepareEvent>` for `{ model?, cacheDir? }` (model defaults to `DEFAULT_LOCAL_MODEL`). Loads the model once, yielding `progress` events (with `ratio`, `loadedBytes`, `totalBytes`, `file` when known) and then a single `ready` or `error`. The loaded pipeline is not shared: a provider loads its own copy from the cache on first `invoke()`.
+- **`ModelProvider`**, **`PrepareEvent`** — type re-exports from `@kindgi/capabilities`.
+
+## Example
+
+```ts
+import { createProviderRegistry } from '@kindgi/capabilities';
+import {
+  createInProcessModelProvider,
+  prepareInProcessModel,
+} from '@kindgi/adapter-model-in-process';
+
+// Download (or verify the cached copy of) the weights before serving traffic.
+for await (const event of prepareInProcessModel({ model: 'smollm2-360m' })) {
+  if (event.kind === 'error') throw new Error(event.message);
+  if (event.kind === 'progress' && event.ratio !== undefined) {
+    console.log(`${event.file ?? 'model'} ${Math.round(event.ratio * 100)}%`);
+  }
+}
+
+const provider = createInProcessModelProvider({ models: ['smollm2-360m'] });
+const { registry } = createProviderRegistry();
+registry.register(tenantId, provider); // metadata.id: 'in-process/smollm2-360m'
+
+const result = await provider.invoke({
+  model: 'smollm2-360m',
+  messages: [
+    { role: 'system', content: 'Classify the ticket as billing, bug or other. Reply with one word.' },
+    { role: 'user', content: 'I was charged twice for the acme plan this month.' },
+  ],
+  maxOutputTokens: 8,
+});
+console.log(result.message.content, result.usage); // costUsd is always 0
+```
+
+## Non-goals
+
+- **Streaming.** `invoke()` resolves with the complete response.
+- **Tool calling and structured output.** `tools`, `structuredOutput`, and message `toolCalls` / `toolCallId` are not passed to the model; responses are plain text.
+- **Arbitrary Hugging Face models.** Only the three `LocalModel` keys are selectable.
+
+## Related
+
+- [`@kindgi/capabilities`](../../capabilities/) — `ModelProvider`, the provider registry, and `AdapterFactoryEntry`.
+- [`@kindgi/adapter-model-openai-compat`](../model-openai-compat/) — for local runners that expose an OpenAI-compatible HTTP endpoint instead.
+- [`@kindgi/dev-echo-provider`](../../dev-echo-provider/) — deterministic scripted provider for tests.

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { DEFAULT_LOCAL_MODEL, MODEL_SPECS, createInProcessModelProvider, } from './provider.js';
+export type { InProcessProviderOptions, LocalModel, ModelSpec } from './provider.js';
+export { prepareInProcessModel } from './prepare.js';
+export type { PrepareInProcessParams } from './prepare.js';
+export type { ModelProvider, PrepareEvent } from '@kindgi/capabilities';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,4BAA4B,GAC7B,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,wBAAwB,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2026 Kindgi Inc.
+export { DEFAULT_LOCAL_MODEL, MODEL_SPECS, createInProcessModelProvider, } from './provider.js';
+export { prepareInProcessModel } from './prepare.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,iCAAiC;AAEjC,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,4BAA4B,GAC7B,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC"}

package/dist/models.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Model registry — three selectable tiers, all Apache 2.0.
+ *
+ * Sizes are approximate q4f16 (4-bit quantization, float16 activations)
+ * download sizes. The first `invoke()` naming a model (or a
+ * `prepareInProcessModel` run for it) downloads the files into the
+ * transformers.js cache; later loads read from the cache. The default
+ * cache is transformers.js's own `env.cacheDir` — with
+ * `@huggingface/transformers` 4.x, a `.cache` directory inside that
+ * package's install location. The `cacheDir` option (provider and
+ * prepare) is passed to the pipeline as `cache_dir` and redirects the
+ * model files; transformers.js 4.3 can still write a model's
+ * `config.json` to its default cache.
+ *
+ * Positioning per tier:
+ *   - `smollm2-135m` — ultra-light. Routing, tag extraction, short
+ *     classification, simple JSON. Do not use for reasoning or math.
+ *   - `smollm2-360m` — default. Instruction-tuned with function-calling,
+ *     summarisation and rewriting data. Best quality-per-megabyte in the
+ *     tier.
+ *   - `qwen3-0.6b` — highest local quality. Larger download; better on
+ *     reasoning / longer contexts.
+ */
+export type LocalModel = 'smollm2-135m' | 'smollm2-360m' | 'qwen3-0.6b';
+export interface ModelSpec {
+    /** Hugging Face hub repo id — must have transformers.js-compatible ONNX assets. */
+    readonly hfName: string;
+    /** Approximate q4f16 download size in MB. */
+    readonly approxDownloadMb: number;
+    /** Model context window in tokens. */
+    readonly contextWindow: number;
+    /** Whether the model was tuned for tool / function-calling use. */
+    readonly toolUse: boolean;
+    /** Rough size tier — added to the provider's `attributes` and each model's `description`. */
+    readonly tier: 'ultra-light' | 'small' | 'medium';
+    /** Suitable-for hints for capability router preference matching. */
+    readonly suitableFor: readonly string[];
+    /** dtype passed to transformers.js pipeline. Balances quality vs size. */
+    readonly dtype: 'q4f16' | 'q8' | 'fp16' | 'fp32';
+}
+export declare const MODEL_SPECS: Record<LocalModel, ModelSpec>;
+/** Default model when none supplied — best quality-per-MB in the tier. */
+export declare const DEFAULT_LOCAL_MODEL: LocalModel;
+//# sourceMappingURL=models.d.ts.map

package/dist/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../src/models.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,cAAc,GAAG,YAAY,CAAC;AAExE,MAAM,WAAW,SAAS;IACxB,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,sCAAsC;IACtC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,GAAG,QAAQ,CAAC;IAClD,oEAAoE;IACpE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,CAAC;CAClD;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,UAAU,EAAE,SAAS,CAmCrD,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,mBAAmB,EAAE,UAA2B,CAAC"}

package/dist/models.js

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2026 Kindgi Inc.
+export const MODEL_SPECS = {
+    'smollm2-135m': {
+        hfName: 'HuggingFaceTB/SmolLM2-135M-Instruct',
+        approxDownloadMb: 118,
+        contextWindow: 8192,
+        toolUse: false,
+        tier: 'ultra-light',
+        suitableFor: ['routing', 'classification', 'smoke-test', 'local', 'lower-cost'],
+        dtype: 'q4f16',
+    },
+    'smollm2-360m': {
+        hfName: 'HuggingFaceTB/SmolLM2-360M-Instruct',
+        approxDownloadMb: 273,
+        contextWindow: 8192,
+        toolUse: true,
+        tier: 'small',
+        suitableFor: [
+            'routing',
+            'classification',
+            'extraction',
+            'summarization',
+            'local',
+            'lower-cost',
+        ],
+        dtype: 'q4f16',
+    },
+    'qwen3-0.6b': {
+        hfName: 'onnx-community/Qwen3-0.6B-ONNX',
+        approxDownloadMb: 550,
+        contextWindow: 32_768,
+        toolUse: true,
+        tier: 'medium',
+        suitableFor: ['reasoning', 'routing', 'classification', 'extraction', 'long-context', 'local'],
+        dtype: 'q4f16',
+    },
+};
+/** Default model when none supplied — best quality-per-MB in the tier. */
+export const DEFAULT_LOCAL_MODEL = 'smollm2-360m';
+//# sourceMappingURL=models.js.map

package/dist/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../src/models.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,iCAAiC;AA4CjC,MAAM,CAAC,MAAM,WAAW,GAAkC;IACxD,cAAc,EAAE;QACd,MAAM,EAAE,qCAAqC;QAC7C,gBAAgB,EAAE,GAAG;QACrB,aAAa,EAAE,IAAI;QACnB,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,aAAa;QACnB,WAAW,EAAE,CAAC,SAAS,EAAE,gBAAgB,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,CAAC;QAC/E,KAAK,EAAE,OAAO;KACf;IACD,cAAc,EAAE;QACd,MAAM,EAAE,qCAAqC;QAC7C,gBAAgB,EAAE,GAAG;QACrB,aAAa,EAAE,IAAI;QACnB,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,OAAO;QACb,WAAW,EAAE;YACX,SAAS;YACT,gBAAgB;YAChB,YAAY;YACZ,eAAe;YACf,OAAO;YACP,YAAY;SACb;QACD,KAAK,EAAE,OAAO;KACf;IACD,YAAY,EAAE;QACZ,MAAM,EAAE,gCAAgC;QACxC,gBAAgB,EAAE,GAAG;QACrB,aAAa,EAAE,MAAM;QACrB,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,QAAQ;QACd,WAAW,EAAE,CAAC,WAAW,EAAE,SAAS,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,OAAO,CAAC;QAC9F,KAAK,EAAE,OAAO;KACf;CACF,CAAC;AAEF,0EAA0E;AAC1E,MAAM,CAAC,MAAM,mBAAmB,GAAe,cAAc,CAAC"}

package/dist/prepare.d.ts

@@ -0,0 +1,44 @@
+import type { PrepareEvent } from '@kindgi/capabilities';
+import { type LocalModel } from './models.js';
+/**
+ * `prepareInProcessModel` — the in-process adapter's download / warmup
+ * step, in the shape of `AdapterFactoryEntry.prepare()` from
+ * `@kindgi/capabilities`. Streams download / warmup progress as
+ * framework `PrepareEvent`s so an HTTP SSE endpoint (such as
+ * `POST /v1/adapters/:adapterId/prepare` in `@kindgi/api`) can stream
+ * them to a client.
+ *
+ * What happens under the hood:
+ *   0. Yield a first `progress` event naming the model and its
+ *      approximate download size, before any callback fires.
+ *   1. Dynamically import `@huggingface/transformers` (kept
+ *      dynamic so shape tests don't touch the ONNX runtime).
+ *   2. Call `pipeline('text-generation', hfName, {dtype,
+ *      progress_callback})`. First run: transformers.js downloads
+ *      the model into its cache (`cacheDir` when set, passed as
+ *      `cache_dir`; otherwise transformers.js's default, see
+ *      `models.ts`). Subsequent runs hit the cache — the callback
+ *      still fires but reports zero-byte "downloads."
+ *   3. The pipeline's progress_callback fires with events like
+ *      `{status: 'initiate' | 'download' | 'progress' | 'done',
+ *      name, file, progress?, loaded?, total?}`. We translate each
+ *      into a `PrepareEvent` and enqueue it for the async iterator
+ *      to yield.
+ *   4. When the pipeline promise resolves → emit `{kind: 'ready'}`
+ *      and end the stream. On rejection → emit
+ *      `{kind: 'error', message}` and end.
+ *
+ * Consumer pattern (e.g. inside an SSE route):
+ * ```ts
+ * for await (const event of prepareInProcessModel({model: 'smollm2-360m'})) {
+ *   sendSse(event);
+ * }
+ * ```
+ */
+export interface PrepareInProcessParams {
+    readonly model?: LocalModel;
+    /** Directory for downloaded model files, passed to transformers.js as `cache_dir`. */
+    readonly cacheDir?: string;
+}
+export declare function prepareInProcessModel(params?: PrepareInProcessParams): AsyncIterable<PrepareEvent>;
+//# sourceMappingURL=prepare.d.ts.map

package/dist/prepare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare.d.ts","sourceRoot":"","sources":["../src/prepare.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,EAAuB,KAAK,UAAU,EAAe,MAAM,aAAa,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAWD,wBAAuB,qBAAqB,CAC1C,MAAM,GAAE,sBAA2B,GAClC,aAAa,CAAC,YAAY,CAAC,CA0G7B"}

package/dist/prepare.js

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2026 Kindgi Inc.
+import { DEFAULT_LOCAL_MODEL, MODEL_SPECS } from './models.js';
+export async function* prepareInProcessModel(params = {}) {
+    const modelKey = params.model ?? DEFAULT_LOCAL_MODEL;
+    const spec = MODEL_SPECS[modelKey];
+    const queue = [];
+    let resolveWait;
+    let ended = false;
+    const enqueue = (event) => {
+        queue.push(event);
+        const w = resolveWait;
+        resolveWait = undefined;
+        w?.();
+    };
+    const finish = (event) => {
+        queue.push(event);
+        ended = true;
+        const w = resolveWait;
+        resolveWait = undefined;
+        w?.();
+    };
+    const progressCallback = (raw) => {
+        if (raw === null || typeof raw !== 'object')
+            return;
+        const r = raw;
+        switch (r.status) {
+            case 'initiate':
+                enqueue({
+                    kind: 'progress',
+                    message: `Fetching ${r.file ?? r.name ?? spec.hfName}`,
+                    ...(r.file !== undefined && { file: r.file }),
+                });
+                return;
+            case 'download':
+                enqueue({
+                    kind: 'progress',
+                    message: `Downloading ${r.file ?? r.name ?? spec.hfName}`,
+                    ...(r.file !== undefined && { file: r.file }),
+                });
+                return;
+            case 'progress':
+                if (typeof r.progress === 'number') {
+                    enqueue({
+                        kind: 'progress',
+                        message: `Downloading ${r.file ?? r.name ?? spec.hfName}`,
+                        ratio: Math.max(0, Math.min(1, r.progress / 100)),
+                        ...(typeof r.loaded === 'number' && { loadedBytes: r.loaded }),
+                        ...(typeof r.total === 'number' && { totalBytes: r.total }),
+                        ...(r.file !== undefined && { file: r.file }),
+                    });
+                }
+                return;
+            case 'done':
+                enqueue({
+                    kind: 'progress',
+                    message: `Completed ${r.file ?? r.name ?? spec.hfName}`,
+                    ratio: 1,
+                    ...(r.file !== undefined && { file: r.file }),
+                });
+                return;
+            default:
+                // 'ready' + any unknown status — ignore; the load-promise
+                // resolution is the authoritative "done" signal.
+                return;
+        }
+    };
+    // Kick off the load in parallel with the yield loop.
+    const loadPromise = (async () => {
+        const mod = (await import('@huggingface/transformers'));
+        return mod.pipeline('text-generation', spec.hfName, {
+            dtype: spec.dtype,
+            progress_callback: progressCallback,
+            ...(params.cacheDir !== undefined && { cache_dir: params.cacheDir }),
+        });
+    })();
+    loadPromise.then(() => finish({ kind: 'ready', message: `${spec.hfName} ready` }), (err) => finish({
+        kind: 'error',
+        message: err instanceof Error ? err.message : String(err),
+    }));
+    // Prologue — tell the consumer what's about to happen even before
+    // the callback fires (transformers.js can silently sit on a cache
+    // check for a second or two before emitting anything).
+    yield {
+        kind: 'progress',
+        message: `Preparing ${spec.hfName} (~${spec.approxDownloadMb} MB, ${spec.tier} tier)`,
+    };
+    while (!ended || queue.length > 0) {
+        const next = queue.shift();
+        if (next !== undefined) {
+            yield next;
+            continue;
+        }
+        await new Promise((resolve) => {
+            resolveWait = resolve;
+        });
+    }
+}
+//# sourceMappingURL=prepare.js.map

package/dist/prepare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare.js","sourceRoot":"","sources":["../src/prepare.ts"],"names":[],"mappings":"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"}

package/dist/provider.d.ts

@@ -0,0 +1,43 @@
+import type { ModelProvider } from '@kindgi/capabilities';
+import { type LocalModel } from './models.js';
+export interface InProcessProviderOptions {
+    /**
+     * Local models this provider exposes. Each entry becomes a
+     * `ModelInfo` in the returned `ProviderMetadata.models[]`. Pipelines
+     * are loaded lazily per model on the first invocation that names
+     * them. Defaults to `[DEFAULT_LOCAL_MODEL]` when omitted.
+     */
+    readonly models?: readonly LocalModel[];
+    /**
+     * Override the provider id embedded in `ProviderMetadata.id` — useful
+     * when you want two registrations of the same model set with
+     * different capability declarations (e.g. one for routing, one for
+     * extraction).
+     */
+    readonly providerId?: string;
+    /**
+     * Directory for downloaded model files, passed to transformers.js as
+     * `cache_dir`. Defaults to transformers.js's own cache (`env.cacheDir`;
+     * see `models.ts`).
+     */
+    readonly cacheDir?: string;
+}
+/**
+ * Create an in-process `ModelProvider` backed by `@huggingface/transformers`.
+ *
+ * Pipelines are loaded lazily per model on the first `invoke()` call
+ * that names them — construction of the provider is cheap. Model
+ * weights download into the transformers.js cache (or `cacheDir`) on
+ * first use; later loads read from the cache.
+ *
+ * Cost is always `0` USD (no external service). Resource-usage recording
+ * still tracks token counts + duration so operators can see the local
+ * model's real load in aggregate reports.
+ *
+ * The returned provider is safe to share process-wide; each underlying
+ * pipeline serialises its own requests inside the ONNX runtime.
+ */
+export declare function createInProcessModelProvider(options?: InProcessProviderOptions): ModelProvider;
+export type { LocalModel, ModelSpec } from './models.js';
+export { MODEL_SPECS, DEFAULT_LOCAL_MODEL } from './models.js';
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAMV,aAAa,EAEd,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAuB,KAAK,UAAU,EAA+B,MAAM,aAAa,CAAC;AAoBhG,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,GAAE,wBAA6B,GACrC,aAAa,CA2Ef;AAsFD,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC"}