@dbx-tools/appkit-model-gateway 0.9.36

package/lib/src/models.js

@@ -0,0 +1,119 @@
+/**
+ * OpenAI and Codex model-list payloads derived from the live registry.
+ *
+ * @module
+ */
+import { isChatClass } from "@dbx-tools/model/classes";
+const CODEX_BASE_INSTRUCTIONS = "You are a coding agent. Follow the user's instructions and use the available tools to work in the current repository.";
+const REASONING_DESCRIPTIONS = {
+    none: "Disable explicit reasoning",
+    minimal: "Use the smallest available reasoning budget",
+    low: "Use a low reasoning budget",
+    medium: "Use a medium reasoning budget",
+    high: "Use a high reasoning budget",
+    xhigh: "Use an extra-high reasoning budget",
+    max: "Use the largest available reasoning budget",
+};
+export function listModelsPayload(targets, includeCodex) {
+    const available = targets
+        .filter((target) => target.endpoint?.status?.deprecated !== true)
+        .filter((target) => !includeCodex || hasChatClass(target))
+        .slice()
+        .sort(compareCatalogueTargets);
+    if (includeCodex) {
+        return {
+            models: available.map((target, index) => codexModel(target, index + 1)),
+        };
+    }
+    return {
+        object: "list",
+        data: available.map(openAiModel),
+    };
+}
+function openAiModel(target) {
+    return {
+        id: target.id,
+        object: "model",
+        created: 0,
+        owned_by: "databricks",
+        name: target.displayName,
+        task: target.endpoint?.task,
+        status: target.endpoint?.status ?? { deprecated: false },
+        capabilities: {
+            tools: target.capabilities.tools,
+            reasoning: target.reasoningEfforts,
+            responses: target.capabilities.responses,
+            open_responses: target.capabilities.openResponses,
+            anthropic: target.capabilities.anthropic,
+            embeddings: target.capabilities.embeddings,
+            ai_gateway_codex: target.capabilities.aiGatewayCodex,
+            streaming: target.capabilities.streaming,
+        },
+    };
+}
+function codexModel(target, priority) {
+    const model = target.capabilities.aiGatewayCodex && target.modelServiceName
+        ? target.modelServiceName
+        : target.id;
+    const efforts = target.reasoningEfforts;
+    return {
+        slug: `databricks/${model}`,
+        display_name: target.displayName,
+        description: target.endpoint?.description ?? "Databricks model service",
+        base_instructions: CODEX_BASE_INSTRUCTIONS,
+        status: target.endpoint?.status ?? { deprecated: false },
+        supported_reasoning_levels: efforts.map((effort) => ({
+            effort,
+            description: REASONING_DESCRIPTIONS[effort] ?? `Use the ${effort} reasoning budget`,
+        })),
+        ...(efforts.length > 0
+            ? { default_reasoning_level: efforts.includes("medium") ? "medium" : efforts[0] }
+            : {}),
+        shell_type: "unified_exec",
+        visibility: "list",
+        supported_in_api: true,
+        priority,
+        availability_nux: null,
+        upgrade: null,
+        support_verbosity: false,
+        default_verbosity: null,
+        apply_patch_tool_type: target.capabilities.customTools ? "freeform" : null,
+        truncation_policy: { mode: "tokens", limit: 128_000 },
+        context_window: null,
+        experimental_supported_tools: [],
+        input_modalities: ["text"],
+        web_search_tool_type: "text",
+        supports_search_tool: false,
+        supports_image_detail_original: false,
+    };
+}
+/**
+ * Order listed models by family A-Z, then display name. Targets with no family
+ * follow every named family, still sorted by display name.
+ */
+function compareCatalogueTargets(left, right) {
+    const leftFamily = catalogueFamily(left);
+    const rightFamily = catalogueFamily(right);
+    if (Boolean(leftFamily) !== Boolean(rightFamily))
+        return leftFamily ? -1 : 1;
+    if (leftFamily && rightFamily) {
+        const familyOrder = leftFamily.localeCompare(rightFamily, undefined, { sensitivity: "base" });
+        if (familyOrder !== 0)
+            return familyOrder;
+    }
+    return catalogueName(left).localeCompare(catalogueName(right), undefined, {
+        sensitivity: "base",
+    });
+}
+function catalogueFamily(target) {
+    const family = target.family?.trim() || target.endpoint?.family?.trim();
+    return family || undefined;
+}
+function catalogueName(target) {
+    return target.displayName.trim() || target.id;
+}
+function hasChatClass(target) {
+    const modelClass = target.endpoint?.class;
+    return modelClass !== undefined && isChatClass(modelClass);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.js","sourceRoot":"","sources":["../../src/models.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenAI and Codex model-list payloads derived from the live registry.\n *\n * @module\n */\n\nimport { isChatClass } from \"@dbx-tools/model/classes\";\nimport type {\n  CodexModel,\n  CodexModelListResponse,\n  ModelListResponse,\n  ModelTarget,\n  OpenAIModel,\n  OpenAIModelListResponse,\n} from \"@dbx-tools/shared-model-gateway\";\n\nconst CODEX_BASE_INSTRUCTIONS =\n  \"You are a coding agent. Follow the user's instructions and use the available tools to work in the current repository.\";\n\nconst REASONING_DESCRIPTIONS: Readonly<Record<string, string>> = {\n  none: \"Disable explicit reasoning\",\n  minimal: \"Use the smallest available reasoning budget\",\n  low: \"Use a low reasoning budget\",\n  medium: \"Use a medium reasoning budget\",\n  high: \"Use a high reasoning budget\",\n  xhigh: \"Use an extra-high reasoning budget\",\n  max: \"Use the largest available reasoning budget\",\n};\n\n/** Build the combined OpenAI and optional Codex model catalogue. */\nexport function listModelsPayload(\n  targets: readonly ModelTarget[],\n  includeCodex: true,\n): CodexModelListResponse;\nexport function listModelsPayload(\n  targets: readonly ModelTarget[],\n  includeCodex: false,\n): OpenAIModelListResponse;\nexport function listModelsPayload(\n  targets: readonly ModelTarget[],\n  includeCodex: boolean,\n): ModelListResponse;\nexport function listModelsPayload(\n  targets: readonly ModelTarget[],\n  includeCodex: boolean,\n): ModelListResponse {\n  const available = targets\n    .filter((target) => target.endpoint?.status?.deprecated !== true)\n    .filter((target) => !includeCodex || hasChatClass(target))\n    .slice()\n    .sort(compareCatalogueTargets);\n  if (includeCodex) {\n    return {\n      models: available.map((target, index) => codexModel(target, index + 1)),\n    };\n  }\n  return {\n    object: \"list\",\n    data: available.map(openAiModel),\n  };\n}\n\nfunction openAiModel(target: ModelTarget): OpenAIModel {\n  return {\n    id: target.id,\n    object: \"model\",\n    created: 0,\n    owned_by: \"databricks\",\n    name: target.displayName,\n    task: target.endpoint?.task,\n    status: target.endpoint?.status ?? { deprecated: false },\n    capabilities: {\n      tools: target.capabilities.tools,\n      reasoning: target.reasoningEfforts,\n      responses: target.capabilities.responses,\n      open_responses: target.capabilities.openResponses,\n      anthropic: target.capabilities.anthropic,\n      embeddings: target.capabilities.embeddings,\n      ai_gateway_codex: target.capabilities.aiGatewayCodex,\n      streaming: target.capabilities.streaming,\n    },\n  };\n}\n\nfunction codexModel(target: ModelTarget, priority: number): CodexModel {\n  const model =\n    target.capabilities.aiGatewayCodex && target.modelServiceName\n      ? target.modelServiceName\n      : target.id;\n  const efforts = target.reasoningEfforts;\n  return {\n    slug: `databricks/${model}`,\n    display_name: target.displayName,\n    description: target.endpoint?.description ?? \"Databricks model service\",\n    base_instructions: CODEX_BASE_INSTRUCTIONS,\n    status: target.endpoint?.status ?? { deprecated: false },\n    supported_reasoning_levels: efforts.map((effort) => ({\n      effort,\n      description: REASONING_DESCRIPTIONS[effort] ?? `Use the ${effort} reasoning budget`,\n    })),\n    ...(efforts.length > 0\n      ? { default_reasoning_level: efforts.includes(\"medium\") ? \"medium\" : efforts[0] }\n      : {}),\n    shell_type: \"unified_exec\",\n    visibility: \"list\",\n    supported_in_api: true,\n    priority,\n    availability_nux: null,\n    upgrade: null,\n    support_verbosity: false,\n    default_verbosity: null,\n    apply_patch_tool_type: target.capabilities.customTools ? \"freeform\" : null,\n    truncation_policy: { mode: \"tokens\", limit: 128_000 },\n    context_window: null,\n    experimental_supported_tools: [],\n    input_modalities: [\"text\"],\n    web_search_tool_type: \"text\",\n    supports_search_tool: false,\n    supports_image_detail_original: false,\n  };\n}\n\n/**\n * Order listed models by family A-Z, then display name. Targets with no family\n * follow every named family, still sorted by display name.\n */\nfunction compareCatalogueTargets(left: ModelTarget, right: ModelTarget): number {\n  const leftFamily = catalogueFamily(left);\n  const rightFamily = catalogueFamily(right);\n  if (Boolean(leftFamily) !== Boolean(rightFamily)) return leftFamily ? -1 : 1;\n  if (leftFamily && rightFamily) {\n    const familyOrder = leftFamily.localeCompare(rightFamily, undefined, { sensitivity: \"base\" });\n    if (familyOrder !== 0) return familyOrder;\n  }\n  return catalogueName(left).localeCompare(catalogueName(right), undefined, {\n    sensitivity: \"base\",\n  });\n}\n\nfunction catalogueFamily(target: ModelTarget): string | undefined {\n  const family = target.family?.trim() || target.endpoint?.family?.trim();\n  return family || undefined;\n}\n\nfunction catalogueName(target: ModelTarget): string {\n  return target.displayName.trim() || target.id;\n}\n\nfunction hasChatClass(target: ModelTarget): boolean {\n  const modelClass = target.endpoint?.class;\n  return modelClass !== undefined && isChatClass(modelClass);\n}\n"]}

package/lib/src/plugin.d.ts

@@ -0,0 +1,32 @@
+/**
+ * AppKit model-gateway plugin.
+ *
+ * @module
+ */
+import { Plugin, type BasePluginConfig, type IAppRouter } from "@databricks/appkit";
+import type { ClientProtocol } from "@dbx-tools/shared-model-gateway";
+import type express from "express";
+import { type ModelGatewayOptions } from "./gateway.ts";
+/** AppKit configuration for the model-gateway plugin. */
+export interface ModelGatewayPluginConfig extends BasePluginConfig, ModelGatewayOptions {
+}
+/** AppKit plugin exposing dynamic model discovery and compatibility routes. */
+export declare class ModelGatewayPlugin extends Plugin<ModelGatewayPluginConfig> {
+    static manifest: import("@databricks/appkit").PluginManifest<"modelGateway">;
+    private readonly gateway;
+    constructor(config?: ModelGatewayPluginConfig);
+    injectRoutes(router: IAppRouter): void;
+    /** Send the active principal's model catalogue. */
+    models(request: express.Request, response: express.Response): Promise<void>;
+    /** Execute one compatibility request in the active AppKit identity scope. */
+    inference(protocol: ClientProtocol, request: express.Request, response: express.Response): Promise<void>;
+    /** Refresh the active principal's model catalogue. */
+    refresh(): Promise<void>;
+    exports(): {
+        models: (request: express.Request, response: express.Response) => Promise<void>;
+        inference: (protocol: ClientProtocol, request: express.Request, response: express.Response) => Promise<void>;
+        refresh: () => Promise<void>;
+    };
+}
+/** AppKit plugin factory for the Databricks model gateway. */
+export declare const modelGateway: import("@databricks/appkit").ToPlugin<typeof ModelGatewayPlugin, ModelGatewayPluginConfig | undefined, "modelGateway">;

package/lib/src/plugin.js

@@ -0,0 +1,70 @@
+/**
+ * AppKit model-gateway plugin.
+ *
+ * @module
+ */
+import { defineManifest, Plugin, toPlugin, } from "@databricks/appkit";
+import { ModelGateway } from "./gateway.js";
+import manifest from "./manifest.json" with { type: "json" };
+import { sendHealth, sendInference, sendModels } from "./routes.js";
+/** AppKit plugin exposing dynamic model discovery and compatibility routes. */
+export class ModelGatewayPlugin extends Plugin {
+    static manifest = defineManifest(manifest);
+    gateway;
+    constructor(config = {}) {
+        super(config);
+        this.gateway = new ModelGateway({
+            ...(config.cacheTtlMs !== undefined ? { cacheTtlMs: config.cacheTtlMs } : {}),
+            ...(config.overrides ? { overrides: config.overrides } : {}),
+        });
+    }
+    injectRoutes(router) {
+        this.route(router, {
+            name: "health",
+            method: "get",
+            path: "/healthz",
+            handler: async (_request, response) => sendHealth(response),
+        });
+        this.route(router, {
+            name: "models",
+            method: "get",
+            path: "/v1/models",
+            handler: (request, response) => this.models(request, response),
+        });
+        for (const [name, path, protocol] of [
+            ["chatCompletions", "/v1/chat/completions", "openai-chat"],
+            ["responses", "/v1/responses", "openai-responses"],
+            ["messages", "/v1/messages", "anthropic-messages"],
+            ["embeddings", "/v1/embeddings", "openai-embeddings"],
+        ]) {
+            this.route(router, {
+                name,
+                method: "post",
+                path,
+                handler: (request, response) => this.inference(protocol, request, response),
+            });
+        }
+    }
+    /** Send the active principal's model catalogue. */
+    async models(request, response) {
+        await sendModels(this.gateway, request, response);
+    }
+    /** Execute one compatibility request in the active AppKit identity scope. */
+    async inference(protocol, request, response) {
+        await sendInference(this.gateway, protocol, request, response);
+    }
+    /** Refresh the active principal's model catalogue. */
+    async refresh() {
+        await this.gateway.refresh();
+    }
+    exports() {
+        return {
+            models: this.models,
+            inference: this.inference,
+            refresh: this.refresh,
+        };
+    }
+}
+/** AppKit plugin factory for the Databricks model gateway. */
+export const modelGateway = toPlugin(ModelGatewayPlugin);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3BsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBRUgsT0FBTyxFQUNMLGNBQWMsRUFDZCxNQUFNLEVBQ04sUUFBUSxHQUdULE1BQU0sb0JBQW9CLENBQUM7QUFJNUIsT0FBTyxFQUFFLFlBQVksRUFBNEIsTUFBTSxjQUFjLENBQUM7QUFDdEUsT0FBTyxRQUFRLE1BQU0saUJBQWlCLENBQUMsT0FBTyxJQUFJLEVBQUUsTUFBTSxFQUFFLENBQUM7QUFDN0QsT0FBTyxFQUFFLFVBQVUsRUFBRSxhQUFhLEVBQUUsVUFBVSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBS3BFLCtFQUErRTtBQUMvRSxNQUFNLE9BQU8sa0JBQW1CLFNBQVEsTUFBZ0M7SUFDdEUsTUFBTSxDQUFDLFFBQVEsR0FBRyxjQUFjLENBQWlCLFFBQVEsQ0FBQyxDQUFDO0lBRTFDLE9BQU8sQ0FBZTtJQUV2QyxZQUFZLFNBQW1DLEVBQUU7UUFDL0MsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ2QsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLFlBQVksQ0FBQztZQUM5QixHQUFHLENBQUMsTUFBTSxDQUFDLFVBQVUsS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sQ0FBQyxVQUFVLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQzdFLEdBQUcsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLFNBQVMsRUFBRSxNQUFNLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztTQUM3RCxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRVEsWUFBWSxDQUFDLE1BQWtCO1FBQ3RDLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFO1lBQ2pCLElBQUksRUFBRSxRQUFRO1lBQ2QsTUFBTSxFQUFFLEtBQUs7WUFDYixJQUFJLEVBQUUsVUFBVTtZQUNoQixPQUFPLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUM7U0FDNUQsQ0FBQyxDQUFDO1FBQ0gsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUU7WUFDakIsSUFBSSxFQUFFLFFBQVE7WUFDZCxNQUFNLEVBQUUsS0FBSztZQUNiLElBQUksRUFBRSxZQUFZO1lBQ2xCLE9BQU8sRUFBRSxDQUFDLE9BQU8sRUFBRSxRQUFRLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQztTQUMvRCxDQUFDLENBQUM7UUFDSCxLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLFFBQVEsQ0FBQyxJQUFJO1lBQ25DLENBQUMsaUJBQWlCLEVBQUUsc0JBQXNCLEVBQUUsYUFBYSxDQUFDO1lBQzFELENBQUMsV0FBVyxFQUFFLGVBQWUsRUFBRSxrQkFBa0IsQ0FBQztZQUNsRCxDQUFDLFVBQVUsRUFBRSxjQUFjLEVBQUUsb0JBQW9CLENBQUM7WUFDbEQsQ0FBQyxZQUFZLEVBQUUsZ0JBQWdCLEVBQUUsbUJBQW1CLENBQUM7U0FDN0MsRUFBRSxDQUFDO1lBQ1gsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUU7Z0JBQ2pCLElBQUk7Z0JBQ0osTUFBTSxFQUFFLE1BQU07Z0JBQ2QsSUFBSTtnQkFDSixPQUFPLEVBQUUsQ0FBQyxPQUFPLEVBQUUsUUFBUSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRSxPQUFPLEVBQUUsUUFBUSxDQUFDO2FBQzVFLENBQUMsQ0FBQztRQUNMLENBQUM7SUFDSCxDQUFDO0lBRUQsbURBQW1EO0lBQ25ELEtBQUssQ0FBQyxNQUFNLENBQUMsT0FBd0IsRUFBRSxRQUEwQjtRQUMvRCxNQUFNLFVBQVUsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQztJQUNwRCxDQUFDO0lBRUQsNkVBQTZFO0lBQzdFLEtBQUssQ0FBQyxTQUFTLENBQ2IsUUFBd0IsRUFDeEIsT0FBd0IsRUFDeEIsUUFBMEI7UUFFMUIsTUFBTSxhQUFhLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ2pFLENBQUM7SUFFRCxzREFBc0Q7SUFDdEQsS0FBSyxDQUFDLE9BQU87UUFDWCxNQUFNLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUVRLE9BQU87UUFDZCxPQUFPO1lBQ0wsTUFBTSxFQUFFLElBQUksQ0FBQyxNQUFNO1lBQ25CLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUztZQUN6QixPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU87U0FDdEIsQ0FBQztJQUNKLENBQUM7O0FBR0gsOERBQThEO0FBQzlELE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxRQUFRLENBQUMsa0JBQWtCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQXBwS2l0IG1vZGVsLWdhdGV3YXkgcGx1Z2luLlxuICpcbiAqIEBtb2R1bGVcbiAqL1xuXG5pbXBvcnQge1xuICBkZWZpbmVNYW5pZmVzdCxcbiAgUGx1Z2luLFxuICB0b1BsdWdpbixcbiAgdHlwZSBCYXNlUGx1Z2luQ29uZmlnLFxuICB0eXBlIElBcHBSb3V0ZXIsXG59IGZyb20gXCJAZGF0YWJyaWNrcy9hcHBraXRcIjtcbmltcG9ydCB0eXBlIHsgQ2xpZW50UHJvdG9jb2wgfSBmcm9tIFwiQGRieC10b29scy9zaGFyZWQtbW9kZWwtZ2F0ZXdheVwiO1xuaW1wb3J0IHR5cGUgZXhwcmVzcyBmcm9tIFwiZXhwcmVzc1wiO1xuXG5pbXBvcnQgeyBNb2RlbEdhdGV3YXksIHR5cGUgTW9kZWxHYXRld2F5T3B0aW9ucyB9IGZyb20gXCIuL2dhdGV3YXkudHNcIjtcbmltcG9ydCBtYW5pZmVzdCBmcm9tIFwiLi9tYW5pZmVzdC5qc29uXCIgd2l0aCB7IHR5cGU6IFwianNvblwiIH07XG5pbXBvcnQgeyBzZW5kSGVhbHRoLCBzZW5kSW5mZXJlbmNlLCBzZW5kTW9kZWxzIH0gZnJvbSBcIi4vcm91dGVzLnRzXCI7XG5cbi8qKiBBcHBLaXQgY29uZmlndXJhdGlvbiBmb3IgdGhlIG1vZGVsLWdhdGV3YXkgcGx1Z2luLiAqL1xuZXhwb3J0IGludGVyZmFjZSBNb2RlbEdhdGV3YXlQbHVnaW5Db25maWcgZXh0ZW5kcyBCYXNlUGx1Z2luQ29uZmlnLCBNb2RlbEdhdGV3YXlPcHRpb25zIHt9XG5cbi8qKiBBcHBLaXQgcGx1Z2luIGV4cG9zaW5nIGR5bmFtaWMgbW9kZWwgZGlzY292ZXJ5IGFuZCBjb21wYXRpYmlsaXR5IHJvdXRlcy4gKi9cbmV4cG9ydCBjbGFzcyBNb2RlbEdhdGV3YXlQbHVnaW4gZXh0ZW5kcyBQbHVnaW48TW9kZWxHYXRld2F5UGx1Z2luQ29uZmlnPiB7XG4gIHN0YXRpYyBtYW5pZmVzdCA9IGRlZmluZU1hbmlmZXN0PFwibW9kZWxHYXRld2F5XCI+KG1hbmlmZXN0KTtcblxuICBwcml2YXRlIHJlYWRvbmx5IGdhdGV3YXk6IE1vZGVsR2F0ZXdheTtcblxuICBjb25zdHJ1Y3Rvcihjb25maWc6IE1vZGVsR2F0ZXdheVBsdWdpbkNvbmZpZyA9IHt9KSB7XG4gICAgc3VwZXIoY29uZmlnKTtcbiAgICB0aGlzLmdhdGV3YXkgPSBuZXcgTW9kZWxHYXRld2F5KHtcbiAgICAgIC4uLihjb25maWcuY2FjaGVUdGxNcyAhPT0gdW5kZWZpbmVkID8geyBjYWNoZVR0bE1zOiBjb25maWcuY2FjaGVUdGxNcyB9IDoge30pLFxuICAgICAgLi4uKGNvbmZpZy5vdmVycmlkZXMgPyB7IG92ZXJyaWRlczogY29uZmlnLm92ZXJyaWRlcyB9IDoge30pLFxuICAgIH0pO1xuICB9XG5cbiAgb3ZlcnJpZGUgaW5qZWN0Um91dGVzKHJvdXRlcjogSUFwcFJvdXRlcik6IHZvaWQge1xuICAgIHRoaXMucm91dGUocm91dGVyLCB7XG4gICAgICBuYW1lOiBcImhlYWx0aFwiLFxuICAgICAgbWV0aG9kOiBcImdldFwiLFxuICAgICAgcGF0aDogXCIvaGVhbHRoelwiLFxuICAgICAgaGFuZGxlcjogYXN5bmMgKF9yZXF1ZXN0LCByZXNwb25zZSkgPT4gc2VuZEhlYWx0aChyZXNwb25zZSksXG4gICAgfSk7XG4gICAgdGhpcy5yb3V0ZShyb3V0ZXIsIHtcbiAgICAgIG5hbWU6IFwibW9kZWxzXCIsXG4gICAgICBtZXRob2Q6IFwiZ2V0XCIsXG4gICAgICBwYXRoOiBcIi92MS9tb2RlbHNcIixcbiAgICAgIGhhbmRsZXI6IChyZXF1ZXN0LCByZXNwb25zZSkgPT4gdGhpcy5tb2RlbHMocmVxdWVzdCwgcmVzcG9uc2UpLFxuICAgIH0pO1xuICAgIGZvciAoY29uc3QgW25hbWUsIHBhdGgsIHByb3RvY29sXSBvZiBbXG4gICAgICBbXCJjaGF0Q29tcGxldGlvbnNcIiwgXCIvdjEvY2hhdC9jb21wbGV0aW9uc1wiLCBcIm9wZW5haS1jaGF0XCJdLFxuICAgICAgW1wicmVzcG9uc2VzXCIsIFwiL3YxL3Jlc3BvbnNlc1wiLCBcIm9wZW5haS1yZXNwb25zZXNcIl0sXG4gICAgICBbXCJtZXNzYWdlc1wiLCBcIi92MS9tZXNzYWdlc1wiLCBcImFudGhyb3BpYy1tZXNzYWdlc1wiXSxcbiAgICAgIFtcImVtYmVkZGluZ3NcIiwgXCIvdjEvZW1iZWRkaW5nc1wiLCBcIm9wZW5haS1lbWJlZGRpbmdzXCJdLFxuICAgIF0gYXMgY29uc3QpIHtcbiAgICAgIHRoaXMucm91dGUocm91dGVyLCB7XG4gICAgICAgIG5hbWUsXG4gICAgICAgIG1ldGhvZDogXCJwb3N0XCIsXG4gICAgICAgIHBhdGgsXG4gICAgICAgIGhhbmRsZXI6IChyZXF1ZXN0LCByZXNwb25zZSkgPT4gdGhpcy5pbmZlcmVuY2UocHJvdG9jb2wsIHJlcXVlc3QsIHJlc3BvbnNlKSxcbiAgICAgIH0pO1xuICAgIH1cbiAgfVxuXG4gIC8qKiBTZW5kIHRoZSBhY3RpdmUgcHJpbmNpcGFsJ3MgbW9kZWwgY2F0YWxvZ3VlLiAqL1xuICBhc3luYyBtb2RlbHMocmVxdWVzdDogZXhwcmVzcy5SZXF1ZXN0LCByZXNwb25zZTogZXhwcmVzcy5SZXNwb25zZSk6IFByb21pc2U8dm9pZD4ge1xuICAgIGF3YWl0IHNlbmRNb2RlbHModGhpcy5nYXRld2F5LCByZXF1ZXN0LCByZXNwb25zZSk7XG4gIH1cblxuICAvKiogRXhlY3V0ZSBvbmUgY29tcGF0aWJpbGl0eSByZXF1ZXN0IGluIHRoZSBhY3RpdmUgQXBwS2l0IGlkZW50aXR5IHNjb3BlLiAqL1xuICBhc3luYyBpbmZlcmVuY2UoXG4gICAgcHJvdG9jb2w6IENsaWVudFByb3RvY29sLFxuICAgIHJlcXVlc3Q6IGV4cHJlc3MuUmVxdWVzdCxcbiAgICByZXNwb25zZTogZXhwcmVzcy5SZXNwb25zZSxcbiAgKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgYXdhaXQgc2VuZEluZmVyZW5jZSh0aGlzLmdhdGV3YXksIHByb3RvY29sLCByZXF1ZXN0LCByZXNwb25zZSk7XG4gIH1cblxuICAvKiogUmVmcmVzaCB0aGUgYWN0aXZlIHByaW5jaXBhbCdzIG1vZGVsIGNhdGFsb2d1ZS4gKi9cbiAgYXN5bmMgcmVmcmVzaCgpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCB0aGlzLmdhdGV3YXkucmVmcmVzaCgpO1xuICB9XG5cbiAgb3ZlcnJpZGUgZXhwb3J0cygpIHtcbiAgICByZXR1cm4ge1xuICAgICAgbW9kZWxzOiB0aGlzLm1vZGVscyxcbiAgICAgIGluZmVyZW5jZTogdGhpcy5pbmZlcmVuY2UsXG4gICAgICByZWZyZXNoOiB0aGlzLnJlZnJlc2gsXG4gICAgfTtcbiAgfVxufVxuXG4vKiogQXBwS2l0IHBsdWdpbiBmYWN0b3J5IGZvciB0aGUgRGF0YWJyaWNrcyBtb2RlbCBnYXRld2F5LiAqL1xuZXhwb3J0IGNvbnN0IG1vZGVsR2F0ZXdheSA9IHRvUGx1Z2luKE1vZGVsR2F0ZXdheVBsdWdpbik7XG4iXX0=

package/lib/src/protocols/decode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * External OpenAI and Anthropic request decoders for AI SDK fallback routes.
+ *
+ * @module
+ */
+import type { ClientProtocol } from "@dbx-tools/shared-model-gateway";
+import { type ModelMessage, type ToolSet } from "ai";
+/** AI SDK call settings decoded from a gateway request. */
+export interface DecodedGatewayRequest {
+    readonly messages: ModelMessage[];
+    readonly tools: ToolSet;
+    readonly maxOutputTokens?: number;
+    readonly temperature?: number;
+    readonly topP?: number;
+}
+/** Decode one supported external protocol into AI SDK model messages and tools. */
+export declare function decodeGatewayRequest(protocol: ClientProtocol, body: Readonly<Record<string, unknown>>): DecodedGatewayRequest;

package/lib/src/protocols/decode.js

@@ -0,0 +1,262 @@
+/**
+ * External OpenAI and Anthropic request decoders for AI SDK fallback routes.
+ *
+ * @module
+ */
+import { dynamicTool, jsonSchema } from "ai";
+/** Decode one supported external protocol into AI SDK model messages and tools. */
+export function decodeGatewayRequest(protocol, body) {
+    const messages = protocol === "openai-responses"
+        ? decodeResponsesMessages(body)
+        : protocol === "anthropic-messages"
+            ? decodeAnthropicMessages(body)
+            : decodeChatMessages(body);
+    return {
+        messages: consolidateSystemMessages(messages),
+        tools: decodeTools(body.tools),
+        ...numberSetting(body, "max_output_tokens", "max_tokens", "max_tokens_to_sample"),
+        ...(finiteNumber(body.temperature) !== undefined
+            ? { temperature: finiteNumber(body.temperature) }
+            : {}),
+        ...(finiteNumber(body.top_p) !== undefined ? { topP: finiteNumber(body.top_p) } : {}),
+    };
+}
+function decodeResponsesMessages(body) {
+    const messages = [];
+    if (typeof body.instructions === "string" && body.instructions.trim()) {
+        messages.push({ role: "system", content: body.instructions });
+    }
+    if (typeof body.input === "string") {
+        messages.push({ role: "user", content: body.input });
+        return messages;
+    }
+    const toolNames = new Map();
+    for (const item of arrayRecords(body.input)) {
+        const type = item.type;
+        if (type === "function_call" || type === "custom_tool_call") {
+            const callId = stringValue(item.call_id) ?? stringValue(item.id) ?? crypto.randomUUID();
+            const toolName = stringValue(item.name) ?? "tool";
+            toolNames.set(callId, toolName);
+            messages.push({
+                role: "assistant",
+                content: [
+                    {
+                        type: "tool-call",
+                        toolCallId: callId,
+                        toolName,
+                        input: parseToolInput(item.arguments ?? item.input),
+                    },
+                ],
+            });
+            continue;
+        }
+        if (type === "function_call_output" || type === "custom_tool_call_output") {
+            const callId = stringValue(item.call_id) ?? stringValue(item.id) ?? crypto.randomUUID();
+            messages.push(toolResultMessage(callId, toolNames.get(callId) ?? "tool", item.output));
+            continue;
+        }
+        const role = messageRole(item.role);
+        if (role)
+            messages.push({ role, content: contentText(item.content) });
+    }
+    return messages;
+}
+function decodeChatMessages(body) {
+    const messages = [];
+    const toolNames = new Map();
+    for (const message of arrayRecords(body.messages)) {
+        const role = stringValue(message.role);
+        if (role === "tool") {
+            const callId = stringValue(message.tool_call_id) ?? crypto.randomUUID();
+            messages.push(toolResultMessage(callId, toolNames.get(callId) ?? "tool", message.content));
+            continue;
+        }
+        if (role === "assistant" && Array.isArray(message.tool_calls)) {
+            const content = [];
+            const text = contentText(message.content);
+            if (text)
+                content.push({ type: "text", text });
+            for (const toolCall of arrayRecords(message.tool_calls)) {
+                const fn = record(toolCall.function);
+                const callId = stringValue(toolCall.id) ?? crypto.randomUUID();
+                const toolName = stringValue(fn.name) ?? "tool";
+                toolNames.set(callId, toolName);
+                content.push({
+                    type: "tool-call",
+                    toolCallId: callId,
+                    toolName,
+                    input: parseToolInput(fn.arguments),
+                });
+            }
+            messages.push({ role: "assistant", content });
+            continue;
+        }
+        const normalized = messageRole(role);
+        if (normalized)
+            messages.push({ role: normalized, content: contentText(message.content) });
+    }
+    return messages;
+}
+function decodeAnthropicMessages(body) {
+    const messages = [];
+    if (body.system !== undefined) {
+        const system = contentText(body.system);
+        if (system)
+            messages.push({ role: "system", content: system });
+    }
+    const toolNames = new Map();
+    for (const message of arrayRecords(body.messages)) {
+        const role = stringValue(message.role);
+        const parts = Array.isArray(message.content) ? message.content : [];
+        if (role === "assistant") {
+            const content = [];
+            for (const part of parts) {
+                if (!record(part).type || record(part).type === "text") {
+                    const text = contentText(part);
+                    if (text)
+                        content.push({ type: "text", text });
+                    continue;
+                }
+                const value = record(part);
+                if (value.type !== "tool_use")
+                    continue;
+                const callId = stringValue(value.id) ?? crypto.randomUUID();
+                const toolName = stringValue(value.name) ?? "tool";
+                toolNames.set(callId, toolName);
+                content.push({
+                    type: "tool-call",
+                    toolCallId: callId,
+                    toolName,
+                    input: value.input ?? {},
+                });
+            }
+            messages.push({ role: "assistant", content });
+            continue;
+        }
+        const textParts = [];
+        for (const part of parts) {
+            const value = record(part);
+            if (value.type === "tool_result") {
+                const callId = stringValue(value.tool_use_id) ?? crypto.randomUUID();
+                messages.push(toolResultMessage(callId, toolNames.get(callId) ?? "tool", value.content));
+            }
+            else {
+                const text = contentText(part);
+                if (text)
+                    textParts.push(text);
+            }
+        }
+        if (textParts.length > 0)
+            messages.push({ role: "user", content: textParts.join("\n") });
+    }
+    return messages;
+}
+function decodeTools(value) {
+    const tools = {};
+    for (const entry of arrayRecords(value)) {
+        const fn = record(entry.function);
+        const name = stringValue(fn.name) ?? stringValue(entry.name);
+        if (!name)
+            continue;
+        const declaredSchema = record(fn.parameters ?? entry.input_schema);
+        const schema = Object.keys(declaredSchema).length > 0
+            ? declaredSchema
+            : entry.type === "custom"
+                ? {
+                    type: "object",
+                    properties: { input: { type: "string" } },
+                    required: ["input"],
+                    additionalProperties: false,
+                }
+                : { type: "object", properties: {}, additionalProperties: false };
+        tools[name] = dynamicTool({
+            description: stringValue(fn.description) ?? stringValue(entry.description),
+            inputSchema: jsonSchema(schema),
+        });
+    }
+    return tools;
+}
+function toolResultMessage(callId, toolName, output) {
+    return {
+        role: "tool",
+        content: [
+            {
+                type: "tool-result",
+                toolCallId: callId,
+                toolName,
+                output: { type: "text", value: contentText(output) },
+            },
+        ],
+    };
+}
+function numberSetting(body, ...names) {
+    for (const name of names) {
+        const value = finiteNumber(body[name]);
+        if (value !== undefined)
+            return { maxOutputTokens: Math.floor(value) };
+    }
+    return {};
+}
+function parseToolInput(value) {
+    if (typeof value !== "string")
+        return value ?? {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return { input: value };
+    }
+}
+function contentText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!Array.isArray(value)) {
+        const text = stringValue(record(value).text);
+        return text ?? (value === undefined || value === null ? "" : JSON.stringify(value));
+    }
+    return value
+        .map((part) => {
+        if (typeof part === "string")
+            return part;
+        const item = record(part);
+        return (stringValue(item.text) ?? stringValue(item.output_text) ?? stringValue(item.input_text));
+    })
+        .filter((text) => text !== undefined)
+        .join("");
+}
+function messageRole(value) {
+    if (value === "system" || value === "developer")
+        return "system";
+    if (value === "user" || value === "assistant")
+        return value;
+    return undefined;
+}
+function arrayRecords(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => isRecord(item))
+        : [];
+}
+function record(value) {
+    return isRecord(value) ? value : {};
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function consolidateSystemMessages(messages) {
+    const system = messages
+        .filter((message) => message.role === "system")
+        .map((message) => (typeof message.content === "string" ? message.content : ""))
+        .filter(Boolean)
+        .join("\n\n");
+    return [
+        ...(system ? [{ role: "system", content: system }] : []),
+        ...messages.filter((message) => message.role !== "system"),
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../../src/protocols/decode.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * External OpenAI and Anthropic request decoders for AI SDK fallback routes.\n *\n * @module\n */\n\nimport type { ClientProtocol } from \"@dbx-tools/shared-model-gateway\";\nimport { dynamicTool, jsonSchema, type ModelMessage, type ToolSet } from \"ai\";\n\n/** AI SDK call settings decoded from a gateway request. */\nexport interface DecodedGatewayRequest {\n  readonly messages: ModelMessage[];\n  readonly tools: ToolSet;\n  readonly maxOutputTokens?: number;\n  readonly temperature?: number;\n  readonly topP?: number;\n}\n\n/** Decode one supported external protocol into AI SDK model messages and tools. */\nexport function decodeGatewayRequest(\n  protocol: ClientProtocol,\n  body: Readonly<Record<string, unknown>>,\n): DecodedGatewayRequest {\n  const messages =\n    protocol === \"openai-responses\"\n      ? decodeResponsesMessages(body)\n      : protocol === \"anthropic-messages\"\n        ? decodeAnthropicMessages(body)\n        : decodeChatMessages(body);\n  return {\n    messages: consolidateSystemMessages(messages),\n    tools: decodeTools(body.tools),\n    ...numberSetting(body, \"max_output_tokens\", \"max_tokens\", \"max_tokens_to_sample\"),\n    ...(finiteNumber(body.temperature) !== undefined\n      ? { temperature: finiteNumber(body.temperature) }\n      : {}),\n    ...(finiteNumber(body.top_p) !== undefined ? { topP: finiteNumber(body.top_p) } : {}),\n  };\n}\n\nfunction decodeResponsesMessages(body: Readonly<Record<string, unknown>>): ModelMessage[] {\n  const messages: ModelMessage[] = [];\n  if (typeof body.instructions === \"string\" && body.instructions.trim()) {\n    messages.push({ role: \"system\", content: body.instructions });\n  }\n  if (typeof body.input === \"string\") {\n    messages.push({ role: \"user\", content: body.input });\n    return messages;\n  }\n  const toolNames = new Map<string, string>();\n  for (const item of arrayRecords(body.input)) {\n    const type = item.type;\n    if (type === \"function_call\" || type === \"custom_tool_call\") {\n      const callId = stringValue(item.call_id) ?? stringValue(item.id) ?? crypto.randomUUID();\n      const toolName = stringValue(item.name) ?? \"tool\";\n      toolNames.set(callId, toolName);\n      messages.push({\n        role: \"assistant\",\n        content: [\n          {\n            type: \"tool-call\",\n            toolCallId: callId,\n            toolName,\n            input: parseToolInput(item.arguments ?? item.input),\n          },\n        ],\n      } as ModelMessage);\n      continue;\n    }\n    if (type === \"function_call_output\" || type === \"custom_tool_call_output\") {\n      const callId = stringValue(item.call_id) ?? stringValue(item.id) ?? crypto.randomUUID();\n      messages.push(toolResultMessage(callId, toolNames.get(callId) ?? \"tool\", item.output));\n      continue;\n    }\n    const role = messageRole(item.role);\n    if (role) messages.push({ role, content: contentText(item.content) } as ModelMessage);\n  }\n  return messages;\n}\n\nfunction decodeChatMessages(body: Readonly<Record<string, unknown>>): ModelMessage[] {\n  const messages: ModelMessage[] = [];\n  const toolNames = new Map<string, string>();\n  for (const message of arrayRecords(body.messages)) {\n    const role = stringValue(message.role);\n    if (role === \"tool\") {\n      const callId = stringValue(message.tool_call_id) ?? crypto.randomUUID();\n      messages.push(toolResultMessage(callId, toolNames.get(callId) ?? \"tool\", message.content));\n      continue;\n    }\n    if (role === \"assistant\" && Array.isArray(message.tool_calls)) {\n      const content: Record<string, unknown>[] = [];\n      const text = contentText(message.content);\n      if (text) content.push({ type: \"text\", text });\n      for (const toolCall of arrayRecords(message.tool_calls)) {\n        const fn = record(toolCall.function);\n        const callId = stringValue(toolCall.id) ?? crypto.randomUUID();\n        const toolName = stringValue(fn.name) ?? \"tool\";\n        toolNames.set(callId, toolName);\n        content.push({\n          type: \"tool-call\",\n          toolCallId: callId,\n          toolName,\n          input: parseToolInput(fn.arguments),\n        });\n      }\n      messages.push({ role: \"assistant\", content } as ModelMessage);\n      continue;\n    }\n    const normalized = messageRole(role);\n    if (normalized) messages.push({ role: normalized, content: contentText(message.content) });\n  }\n  return messages;\n}\n\nfunction decodeAnthropicMessages(body: Readonly<Record<string, unknown>>): ModelMessage[] {\n  const messages: ModelMessage[] = [];\n  if (body.system !== undefined) {\n    const system = contentText(body.system);\n    if (system) messages.push({ role: \"system\", content: system });\n  }\n  const toolNames = new Map<string, string>();\n  for (const message of arrayRecords(body.messages)) {\n    const role = stringValue(message.role);\n    const parts = Array.isArray(message.content) ? message.content : [];\n    if (role === \"assistant\") {\n      const content: Record<string, unknown>[] = [];\n      for (const part of parts) {\n        if (!record(part).type || record(part).type === \"text\") {\n          const text = contentText(part);\n          if (text) content.push({ type: \"text\", text });\n          continue;\n        }\n        const value = record(part);\n        if (value.type !== \"tool_use\") continue;\n        const callId = stringValue(value.id) ?? crypto.randomUUID();\n        const toolName = stringValue(value.name) ?? \"tool\";\n        toolNames.set(callId, toolName);\n        content.push({\n          type: \"tool-call\",\n          toolCallId: callId,\n          toolName,\n          input: value.input ?? {},\n        });\n      }\n      messages.push({ role: \"assistant\", content } as ModelMessage);\n      continue;\n    }\n    const textParts: string[] = [];\n    for (const part of parts) {\n      const value = record(part);\n      if (value.type === \"tool_result\") {\n        const callId = stringValue(value.tool_use_id) ?? crypto.randomUUID();\n        messages.push(toolResultMessage(callId, toolNames.get(callId) ?? \"tool\", value.content));\n      } else {\n        const text = contentText(part);\n        if (text) textParts.push(text);\n      }\n    }\n    if (textParts.length > 0) messages.push({ role: \"user\", content: textParts.join(\"\\n\") });\n  }\n  return messages;\n}\n\nfunction decodeTools(value: unknown): ToolSet {\n  const tools: ToolSet = {};\n  for (const entry of arrayRecords(value)) {\n    const fn = record(entry.function);\n    const name = stringValue(fn.name) ?? stringValue(entry.name);\n    if (!name) continue;\n    const declaredSchema = record(fn.parameters ?? entry.input_schema);\n    const schema =\n      Object.keys(declaredSchema).length > 0\n        ? declaredSchema\n        : entry.type === \"custom\"\n          ? {\n              type: \"object\",\n              properties: { input: { type: \"string\" } },\n              required: [\"input\"],\n              additionalProperties: false,\n            }\n          : { type: \"object\", properties: {}, additionalProperties: false };\n    tools[name] = dynamicTool({\n      description: stringValue(fn.description) ?? stringValue(entry.description),\n      inputSchema: jsonSchema(schema),\n    });\n  }\n  return tools;\n}\n\nfunction toolResultMessage(callId: string, toolName: string, output: unknown): ModelMessage {\n  return {\n    role: \"tool\",\n    content: [\n      {\n        type: \"tool-result\",\n        toolCallId: callId,\n        toolName,\n        output: { type: \"text\", value: contentText(output) },\n      },\n    ],\n  } as ModelMessage;\n}\n\nfunction numberSetting(\n  body: Readonly<Record<string, unknown>>,\n  ...names: readonly string[]\n): Pick<DecodedGatewayRequest, \"maxOutputTokens\"> {\n  for (const name of names) {\n    const value = finiteNumber(body[name]);\n    if (value !== undefined) return { maxOutputTokens: Math.floor(value) };\n  }\n  return {};\n}\n\nfunction parseToolInput(value: unknown): unknown {\n  if (typeof value !== \"string\") return value ?? {};\n  try {\n    return JSON.parse(value);\n  } catch {\n    return { input: value };\n  }\n}\n\nfunction contentText(value: unknown): string {\n  if (typeof value === \"string\") return value;\n  if (!Array.isArray(value)) {\n    const text = stringValue(record(value).text);\n    return text ?? (value === undefined || value === null ? \"\" : JSON.stringify(value));\n  }\n  return value\n    .map((part) => {\n      if (typeof part === \"string\") return part;\n      const item = record(part);\n      return (\n        stringValue(item.text) ?? stringValue(item.output_text) ?? stringValue(item.input_text)\n      );\n    })\n    .filter((text): text is string => text !== undefined)\n    .join(\"\");\n}\n\nfunction messageRole(value: unknown): \"system\" | \"user\" | \"assistant\" | undefined {\n  if (value === \"system\" || value === \"developer\") return \"system\";\n  if (value === \"user\" || value === \"assistant\") return value;\n  return undefined;\n}\n\nfunction arrayRecords(value: unknown): Record<string, unknown>[] {\n  return Array.isArray(value)\n    ? value.filter((item): item is Record<string, unknown> => isRecord(item))\n    : [];\n}\n\nfunction record(value: unknown): Record<string, unknown> {\n  return isRecord(value) ? value : {};\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n\nfunction stringValue(value: unknown): string | undefined {\n  return typeof value === \"string\" ? value : undefined;\n}\n\nfunction finiteNumber(value: unknown): number | undefined {\n  return typeof value === \"number\" && Number.isFinite(value) ? value : undefined;\n}\n\nfunction consolidateSystemMessages(messages: readonly ModelMessage[]): ModelMessage[] {\n  const system = messages\n    .filter((message) => message.role === \"system\")\n    .map((message) => (typeof message.content === \"string\" ? message.content : \"\"))\n    .filter(Boolean)\n    .join(\"\\n\\n\");\n  return [\n    ...(system ? ([{ role: \"system\", content: system }] as ModelMessage[]) : []),\n    ...messages.filter((message) => message.role !== \"system\"),\n  ];\n}\n"]}

package/lib/src/protocols/encode.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Streaming and buffered protocol encoders for AI SDK fallback results.
+ *
+ * @module
+ */
+import type { ClientProtocol } from "@dbx-tools/shared-model-gateway";
+import type { FinishReason, LanguageModelUsage, TextStreamPart, ToolSet, TypedToolCall } from "ai";
+/** Completed AI SDK generation data used by non-streaming encoders. */
+export interface CompletedGeneration {
+    readonly text: string;
+    readonly toolCalls: readonly TypedToolCall<ToolSet>[];
+    readonly usage: LanguageModelUsage;
+    readonly finishReason: FinishReason;
+}
+/** Encode AI SDK events as the requested protocol while preserving backpressure. */
+export declare function encodeGatewayStream(protocol: ClientProtocol, model: string, source: AsyncIterable<TextStreamPart<ToolSet>>): ReadableStream<Uint8Array>;
+/** Encode a completed AI SDK generation as one protocol-native JSON response. */
+export declare function encodeGatewayResponse(protocol: ClientProtocol, model: string, generation: CompletedGeneration): Record<string, unknown>;