@volter/twin-ai-gateway 0.1.0

package/src/ai-gateway-stub.ts

@@ -0,0 +1,115 @@
+import type { ChatMessage } from './ai-gateway-types.ts';
+
+export function contentToText(content: unknown): string {
+  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 as { text?: unknown }).text ?? '');
+      return '';
+    }).filter(Boolean).join(' ');
+  }
+  return '';
+}
+
+export function lastUserText(messages: ChatMessage[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === 'user') return contentToText(messages[i]?.content);
+  }
+  return '';
+}
+
+export function estimateTokens(input: string): number {
+  const trimmed = input.trim();
+  if (!trimmed) return 0;
+  return Math.max(1, Math.ceil(trimmed.length / 4));
+}
+
+export function countPromptTokens(messages: ChatMessage[]): number {
+  return messages.reduce((sum, message) => sum + estimateTokens(`${message.role}: ${contentToText(message.content)}`), 0);
+}
+
+export function stubAssistantText(messages: ChatMessage[], model: string): string {
+  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: unknown): string {
+  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: Record<string, unknown>): string | undefined {
+  const type = schema.type;
+  if (typeof type === 'string') return type;
+  if (Array.isArray(type)) return type.find((item) => item !== 'null' && typeof item === 'string') as string | undefined;
+  return undefined;
+}
+
+function schemaString(key: string): string {
+  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: unknown, key = 'value'): unknown {
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) return {};
+  const s = schema as Record<string, unknown>;
+  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: Record<string, unknown> = {};
+    const props = (s.properties && typeof s.properties === 'object' && !Array.isArray(s.properties))
+      ? s.properties as Record<string, unknown>
+      : {};
+    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 {};
+}
+
+type NormalizedTool = { name: string; parameters: unknown };
+
+export function normalizeTool(tool: unknown): NormalizedTool | null {
+  if (!tool || typeof tool !== 'object') return null;
+  const t = tool as Record<string, unknown>;
+  const fn = t.function && typeof t.function === 'object' ? t.function as Record<string, unknown> : 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: NormalizedTool): Record<string, unknown> {
+  return {
+    id: `call_twin_${stableHash(tool.name).slice(0, 8)}`,
+    type: 'function',
+    function: {
+      name: tool.name,
+      arguments: JSON.stringify(synthesizeJsonSchemaValue(tool.parameters)),
+    },
+  };
+}