@kanzo-tech/llm 0.17.0

package/README.md

@@ -0,0 +1,36 @@
+# @kanzo-tech/llm
+
+The model conversation, without React.
+
+```bash
+npm install @kanzo-tech/llm ai
+```
+
+`ai` is a **required** peer, not an optional one: there is nothing here without it, and a host
+installs it once so that its own agent and `@kanzo-tech/ai`'s components share one `UIMessage`, one
+`ToolLoopAgent` and one transport. Same standing `@uwdata/mosaic-*` have in `@kanzo-tech/mosaic`.
+
+## What it holds
+
+```ts
+import { createKanzo } from "@kanzo-tech/llm";
+import { ToolLoopAgent, DirectChatTransport, tool, Output, streamText } from "@kanzo-tech/llm";
+```
+
+- **`createKanzo({ baseURL })`** — the one door to a model. `kanzo("kanzo-chat")` is a model by
+  **alias**: which upstream answers it is the gateway's configuration, so a host's code is the same
+  in development (a local model) and in production. The gateway speaks OpenAI chat completions; its
+  key belongs to a server, so `baseURL` is normally the host's own authenticated proxy — keasy's is
+  `/api/v1/ai` — and a relative one is resolved against the page. Two things a host would otherwise
+  repeat happen here: a model that reasons inline in `<think>…</think>` (Hermes, DeepSeek, Qwen)
+  gets that lifted into the SDK's `reasoning` part, and structured output is on, so `Output.array`
+  asks the gateway for a JSON schema rather than prose to parse.
+- **Re-exports** of the AI SDK surface a host needs — the agent, the transport, `tool`, `Output`,
+  `streamText`, and the message and part types — so a host never imports `ai` itself.
+  `@ai-sdk/openai-compatible` is not among them: `createKanzo` is the only way to a model.
+
+## Why it is not part of `@kanzo-tech/ai`
+
+Reaching a model is not a user-interface concern, and not every caller draws one: a host's agent,
+a server route or a test needs the model and none of the components. `@kanzo-tech/ai` depends on
+this package and not the other way round.

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The model conversation, as one import.
+ *
+ * Same standing as `@kanzo-tech/mosaic`: the third party — here the AI SDK — is a required peer, its
+ * surface is re-exported so a host never imports `ai` itself, and what is ours is the one door it
+ * does not have. A host reaches a model only through `createKanzo`, an agent through
+ * `ToolLoopAgent`, and a conversation through `@kanzo-tech/ai`'s `useChat`, so one copy of the SDK
+ * is the easy outcome.
+ */
+export { DirectChatTransport, Output, ToolLoopAgent, getToolName, isToolUIPart, jsonSchema, stepCountIs, streamText, tool, type ChatStatus, type DynamicToolUIPart, type InferAgentUIMessage, type LanguageModel, type ReasoningUIPart, type ToolUIPart, type UIMessage, } from "ai";
+/** Ours: the one door to a model. */
+export { createKanzo, type Kanzo, type KanzoSettings } from "./kanzo.js";
+//# 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":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,mBAAmB,EACnB,MAAM,EACN,aAAa,EACb,WAAW,EACX,YAAY,EACZ,UAAU,EACV,WAAW,EACX,UAAU,EACV,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,SAAS,GACf,MAAM,IAAI,CAAC;AAEZ,qCAAqC;AACrC,OAAO,EAAE,WAAW,EAAE,KAAK,KAAK,EAAE,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * The model conversation, as one import.
+ *
+ * Same standing as `@kanzo-tech/mosaic`: the third party — here the AI SDK — is a required peer, its
+ * surface is re-exported so a host never imports `ai` itself, and what is ours is the one door it
+ * does not have. A host reaches a model only through `createKanzo`, an agent through
+ * `ToolLoopAgent`, and a conversation through `@kanzo-tech/ai`'s `useChat`, so one copy of the SDK
+ * is the easy outcome.
+ */
+export { DirectChatTransport, Output, ToolLoopAgent, getToolName, isToolUIPart, jsonSchema, stepCountIs, streamText, tool, } from "ai";
+/** Ours: the one door to a model. */
+export { createKanzo } from "./kanzo.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;;;;;;;;GAQG;AAEH,OAAO,EACL,mBAAmB,EACnB,MAAM,EACN,aAAa,EACb,WAAW,EACX,YAAY,EACZ,UAAU,EACV,WAAW,EACX,UAAU,EACV,IAAI,GAQL,MAAM,IAAI,CAAC;AAEZ,qCAAqC;AACrC,OAAO,EAAE,WAAW,EAAkC,MAAM,YAAY,CAAC"}

package/dist/kanzo.d.ts

@@ -0,0 +1,32 @@
+import { type LanguageModel } from "ai";
+export interface KanzoSettings {
+    /**
+     * Where the gateway's OpenAI-compatible API is, as the browser reaches it. Behind a BFF that is
+     * the host's own proxy — keasy's is `/api/v1/ai` — because the key that opens the gateway must
+     * never be in the page.
+     */
+    baseURL: string;
+    /** Sent with every request; the place for a CSRF header a BFF asks for. */
+    headers?: Record<string, string>;
+    /** The request function, for a host that routes through its own client. */
+    fetch?: typeof globalThis.fetch;
+}
+/** A model behind the gateway, by alias. */
+export type Kanzo = (alias: string) => LanguageModel;
+/**
+ * The one door to a model: name an **alias** (`kanzo-chat`, `kanzo-complete`), never a provider.
+ * Which upstream answers it is the gateway's configuration, so a host's code is the same in dev,
+ * where a local model answers, and in prod.
+ *
+ * Two things a host would otherwise repeat are done here, once:
+ *
+ * - **A model that reasons in tags gets its reasoning back as reasoning.** Open-weight models
+ *   (Hermes, DeepSeek, Qwen) write it inline as `<think>…</think>` because the chat completions
+ *   protocol has no field for it; the middleware lifts it into the SDK's `reasoning` part, which is
+ *   what `Chat` draws as reasoning. A model that never writes the tag is untouched.
+ * - **Structured output is on**, so `Output.object`/`Output.array` ask the gateway for a JSON
+ *   schema rather than prose the caller would parse — the "return ONLY JSON, no fences" prompt and
+ *   its fence-stripping is what this ends.
+ */
+export declare function createKanzo(settings: KanzoSettings): Kanzo;
+//# sourceMappingURL=kanzo.d.ts.map

package/dist/kanzo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kanzo.d.ts","sourceRoot":"","sources":["../src/kanzo.ts"],"names":[],"mappings":"AACA,OAAO,EAA8B,KAAK,aAAa,EAAqB,MAAM,IAAI,CAAC;AAEvF,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,2EAA2E;IAC3E,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAED,4CAA4C;AAC5C,MAAM,MAAM,KAAK,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,aAAa,CAAC;AAErD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,aAAa,GAAG,KAAK,CAW1D"}

package/dist/kanzo.js

@@ -0,0 +1,39 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { extractReasoningMiddleware, wrapLanguageModel } from "ai";
+/**
+ * The one door to a model: name an **alias** (`kanzo-chat`, `kanzo-complete`), never a provider.
+ * Which upstream answers it is the gateway's configuration, so a host's code is the same in dev,
+ * where a local model answers, and in prod.
+ *
+ * Two things a host would otherwise repeat are done here, once:
+ *
+ * - **A model that reasons in tags gets its reasoning back as reasoning.** Open-weight models
+ *   (Hermes, DeepSeek, Qwen) write it inline as `<think>…</think>` because the chat completions
+ *   protocol has no field for it; the middleware lifts it into the SDK's `reasoning` part, which is
+ *   what `Chat` draws as reasoning. A model that never writes the tag is untouched.
+ * - **Structured output is on**, so `Output.object`/`Output.array` ask the gateway for a JSON
+ *   schema rather than prose the caller would parse — the "return ONLY JSON, no fences" prompt and
+ *   its fence-stripping is what this ends.
+ */
+export function createKanzo(settings) {
+    const provider = createOpenAICompatible({
+        name: "kanzo",
+        baseURL: absolute(settings.baseURL),
+        headers: settings.headers,
+        fetch: settings.fetch,
+        includeUsage: true,
+        supportsStructuredOutputs: true,
+    });
+    const reasoning = extractReasoningMiddleware({ tagName: "think" });
+    return (alias) => wrapLanguageModel({ model: provider(alias), middleware: reasoning });
+}
+/**
+ * The provider builds `new URL(baseURL + path)` with no base, so the BFF's own path — the one a
+ * host is told to pass — would throw `Invalid URL` in the browser too. Resolved against the page,
+ * once, here.
+ */
+function absolute(baseURL) {
+    const page = globalThis.location?.href;
+    return page ? new URL(baseURL, page).toString().replace(/\/$/, "") : baseURL;
+}
+//# sourceMappingURL=kanzo.js.map

package/dist/kanzo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kanzo.js","sourceRoot":"","sources":["../src/kanzo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAAE,0BAA0B,EAAsB,iBAAiB,EAAE,MAAM,IAAI,CAAC;AAkBvF;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,WAAW,CAAC,QAAuB;IACjD,MAAM,QAAQ,GAAG,sBAAsB,CAAC;QACtC,IAAI,EAAE,OAAO;QACb,OAAO,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC;QACnC,OAAO,EAAE,QAAQ,CAAC,OAAO;QACzB,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,YAAY,EAAE,IAAI;QAClB,yBAAyB,EAAE,IAAI;KAChC,CAAC,CAAC;IACH,MAAM,SAAS,GAAG,0BAA0B,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;IACnE,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,iBAAiB,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,CAAC;AACzF,CAAC;AAED;;;;GAIG;AACH,SAAS,QAAQ,CAAC,OAAe;IAC/B,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC;IACvC,OAAO,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;AAC/E,CAAC"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@kanzo-tech/llm",
+  "version": "0.17.0",
+  "description": "The model conversation, without React — the AI SDK re-exported as one surface, plus `createKanzo`, the one door to models behind a Kanzo AI gateway.",
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "//dependencies": "@ai-sdk/openai-compatible is a dependency, not a peer: it is how `createKanzo` speaks to the gateway, and nothing outside this package names it — the same standing @duckdb/duckdb-wasm has in @kanzo-tech/mosaic, behind `engine()`.",
+  "//peers": "`ai` is REQUIRED, not optional, and that is the point of this package: there is nothing here without it, and a host installs it once so @kanzo-tech/ai's components and the host's own agent see the same UIMessage, the same ToolLoopAgent and the same transport. Two copies would be two type universes that do not assign to each other.",
+  "dependencies": {
+    "@ai-sdk/openai-compatible": "^3.0.62"
+  },
+  "peerDependencies": {
+    "ai": "^7.0.0"
+  },
+  "devDependencies": {
+    "ai": "^7.0.126"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Kanzo-Tech/ui.git",
+    "directory": "packages/llm"
+  },
+  "homepage": "https://kanzo-tech.github.io/ui",
+  "bugs": {
+    "url": "https://github.com/Kanzo-Tech/ui/issues"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}