@volter/twin-ai-gateway 0.1.0

package/dist/src/ai-gateway-stub.d.ts

@@ -0,0 +1,20 @@
+import type { ChatMessage } from './ai-gateway-types.js';
+export declare function contentToText(content: unknown): string;
+export declare function lastUserText(messages: ChatMessage[]): string;
+export declare function estimateTokens(input: string): number;
+export declare function countPromptTokens(messages: ChatMessage[]): number;
+export declare function stubAssistantText(messages: ChatMessage[], model: string): string;
+export declare function stableHash(value: unknown): string;
+/** Synthesize a deterministic value conforming to a JSON schema — used for json_schema
+ *  structured outputs AND for tool-call arguments, so an unmodified SDK's own schema
+ *  validation of the stubbed output passes. */
+export declare function synthesizeJsonSchemaValue(schema: unknown, key?: string): unknown;
+type NormalizedTool = {
+    name: string;
+    parameters: unknown;
+};
+export declare function normalizeTool(tool: unknown): NormalizedTool | null;
+/** Build the deterministic tool_call the stub emits for a chosen tool: id from the tool name,
+ *  arguments synthesized to CONFORM to the tool's own parameters schema. */
+export declare function buildToolCall(tool: NormalizedTool): Record<string, unknown>;
+export {};

package/dist/src/ai-gateway-stub.js

@@ -0,0 +1,124 @@
+export function contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (part && typeof part === 'object' && 'text' in part)
+                return String(part.text ?? '');
+            return '';
+        }).filter(Boolean).join(' ');
+    }
+    return '';
+}
+export function lastUserText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i]?.role === 'user')
+            return contentToText(messages[i]?.content);
+    }
+    return '';
+}
+export function estimateTokens(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return 0;
+    return Math.max(1, Math.ceil(trimmed.length / 4));
+}
+export function countPromptTokens(messages) {
+    return messages.reduce((sum, message) => sum + estimateTokens(`${message.role}: ${contentToText(message.content)}`), 0);
+}
+export function stubAssistantText(messages, model) {
+    const text = lastUserText(messages) || 'empty prompt';
+    return `[twin-stub:ai-gateway:${model}] Echoing the last user message for deterministic simulation: ${text}`;
+}
+export function stableHash(value) {
+    const s = JSON.stringify(value);
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return (h >>> 0).toString(16).padStart(8, '0');
+}
+function schemaType(schema) {
+    const type = schema.type;
+    if (typeof type === 'string')
+        return type;
+    if (Array.isArray(type))
+        return type.find((item) => item !== 'null' && typeof item === 'string');
+    return undefined;
+}
+function schemaString(key) {
+    const k = key.toLowerCase();
+    if (k.includes('timestamp') || k.includes('date'))
+        return '2026-06-16T00:00:00.000Z';
+    if (k.includes('url'))
+        return 'http://127.0.0.1/twin';
+    if (k.includes('summary'))
+        return 'Twin structured-output stub summary.';
+    if (k.includes('description'))
+        return 'Deterministic twin structured-output stub description.';
+    return 'twin stub';
+}
+/** Synthesize a deterministic value conforming to a JSON schema — used for json_schema
+ *  structured outputs AND for tool-call arguments, so an unmodified SDK's own schema
+ *  validation of the stubbed output passes. */
+export function synthesizeJsonSchemaValue(schema, key = 'value') {
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema))
+        return {};
+    const s = schema;
+    if (Array.isArray(s.enum) && s.enum.length > 0)
+        return s.enum[0];
+    if (Array.isArray(s.const))
+        return s.const[0];
+    if (s.const !== undefined)
+        return s.const;
+    if (Array.isArray(s.anyOf) && s.anyOf.length > 0)
+        return synthesizeJsonSchemaValue(s.anyOf[0], key);
+    if (Array.isArray(s.oneOf) && s.oneOf.length > 0)
+        return synthesizeJsonSchemaValue(s.oneOf[0], key);
+    const type = schemaType(s);
+    if (type === 'object' || (!type && s.properties && typeof s.properties === 'object')) {
+        const out = {};
+        const props = (s.properties && typeof s.properties === 'object' && !Array.isArray(s.properties))
+            ? s.properties
+            : {};
+        for (const [propKey, propSchema] of Object.entries(props)) {
+            out[propKey] = synthesizeJsonSchemaValue(propSchema, propKey);
+        }
+        return out;
+    }
+    if (type === 'array')
+        return [];
+    if (type === 'string')
+        return schemaString(key);
+    if (type === 'number' || type === 'integer')
+        return 0;
+    if (type === 'boolean')
+        return true;
+    if (type === 'null')
+        return null;
+    return {};
+}
+export function normalizeTool(tool) {
+    if (!tool || typeof tool !== 'object')
+        return null;
+    const t = tool;
+    const fn = t.function && typeof t.function === 'object' ? t.function : t;
+    if (typeof fn.name !== 'string' || !fn.name)
+        return null;
+    return { name: fn.name, parameters: fn.parameters };
+}
+/** Build the deterministic tool_call the stub emits for a chosen tool: id from the tool name,
+ *  arguments synthesized to CONFORM to the tool's own parameters schema. */
+export function buildToolCall(tool) {
+    return {
+        id: `call_twin_${stableHash(tool.name).slice(0, 8)}`,
+        type: 'function',
+        function: {
+            name: tool.name,
+            arguments: JSON.stringify(synthesizeJsonSchemaValue(tool.parameters)),
+        },
+    };
+}

package/dist/src/ai-gateway-twin.d.ts

@@ -0,0 +1,2 @@
+import type { AiGatewayRequest, AiGatewayResponse } from './ai-gateway-types.js';
+export declare function handleAiGatewayTwinRequest(req: AiGatewayRequest): Promise<AiGatewayResponse>;