@hotmeshio/long-tail 0.1.0

package/build/services/interceptor/lifecycle.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Interceptor lifecycle helpers.
+ *
+ * Extracted from the main execute() function so the interceptor
+ * reads as a high-level pipeline. Each helper handles one phase
+ * of the workflow lifecycle.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractWorkflowIdentity = extractWorkflowIdentity;
+exports.deriveTaskQueue = deriveTaskQueue;
+exports.resolveReRun = resolveReRun;
+exports.ensureTaskWithRouting = ensureTaskWithRouting;
+exports.publishStartedEvents = publishStartedEvents;
+exports.completePlainResult = completePlainResult;
+const publish_1 = require("../events/publish");
+// ── Helpers ──────────────────────────────────────────────────────────────────
+/** Extract workflow identity fields from the HotMesh context map. */
+function extractWorkflowIdentity(ctx) {
+    return {
+        workflowId: ctx.get('workflowId'),
+        workflowName: ctx.get('workflowName'),
+        workflowTopic: ctx.get('workflowTopic'),
+        workflowTrace: ctx.get('workflowTrace'),
+        workflowSpan: ctx.get('workflowSpan'),
+    };
+}
+/** Derive the task queue from the workflow topic. */
+function deriveTaskQueue(wf) {
+    return wf.workflowTopic
+        ? wf.workflowTopic.replace(new RegExp(`-${wf.workflowName}$`), '')
+        : 'long-tail-examples';
+}
+/**
+ * Detect re-runs and resolve the prior escalation.
+ *
+ * A re-run occurs when `envelope.resolver` + `envelope.lt.escalationId`
+ * are both present — meaning a human (or AI) resolved an escalation
+ * and a new workflow was started with the resolver data.
+ */
+async function resolveReRun(activities, envelope, existingTask, wf, taskQueue) {
+    const isReRun = !!(envelope?.resolver && envelope?.lt?.escalationId);
+    let task = existingTask;
+    let metadata = existingTask?.metadata;
+    // If re-run but no task found by workflowId, look up by the original taskId
+    if (isReRun && !task && envelope?.lt?.taskId) {
+        task = await activities.ltGetTask(envelope.lt.taskId);
+        metadata = task?.metadata;
+    }
+    // Resolve the old escalation (skip auto-triage synthetic IDs —
+    // the triage orchestrator already resolved those)
+    const escalationId = envelope?.lt?.escalationId;
+    const isRealEscalation = isReRun && escalationId && !escalationId.startsWith('auto-triage-');
+    if (isRealEscalation) {
+        await activities.ltResolveEscalation({
+            escalationId: escalationId,
+            resolverPayload: envelope.resolver,
+        });
+        (0, publish_1.publishEscalationEvent)({
+            type: 'escalation.resolved',
+            source: 'interceptor',
+            workflowId: wf.workflowId,
+            workflowName: wf.workflowName,
+            taskQueue,
+            taskId: task?.id || existingTask?.id,
+            escalationId: escalationId,
+            originId: envelope?.lt?.originId,
+            status: 'resolved',
+        });
+    }
+    return { isReRun, task, metadata };
+}
+/**
+ * Ensure a task record exists and resolve routing + origin lineage.
+ *
+ * Handles three cases:
+ * - Task already exists (from executeLT pre-creation) → use it
+ * - Re-run task found by escalation context → reuse it
+ * - No task → create a standalone task
+ *
+ * Also injects originId back into the envelope for downstream consistency.
+ */
+async function ensureTaskWithRouting(activities, wf, envelope, existingTask, taskQueue, reRun) {
+    let taskId = reRun.task?.id || existingTask?.id;
+    let routing = reRun.metadata || existingTask?.metadata;
+    // Fallback: envelope carries routing fields (e.g., from triage auto-resolve)
+    // but the task metadata doesn't have them
+    if (!routing?.parentWorkflowId && envelope?.lt?.parentWorkflowId) {
+        routing = {
+            ...(routing || {}),
+            signalId: envelope.lt.signalId,
+            parentWorkflowId: envelope.lt.parentWorkflowId,
+            parentTaskQueue: envelope.lt.parentTaskQueue,
+            parentWorkflowType: envelope.lt.parentWorkflowType,
+        };
+    }
+    // Canonical originId: traces back to the root workflow
+    const originId = envelope?.lt?.originId
+        || reRun.task?.origin_id
+        || existingTask?.origin_id
+        || wf.workflowId;
+    // Inject originId so escalation records, stored envelopes, and events
+    // all read it consistently
+    if (envelope) {
+        envelope.lt = { ...envelope.lt, originId };
+    }
+    // Create task if none exists, or start a pending one
+    if (!taskId) {
+        taskId = await activities.ltCreateTask({
+            workflowId: wf.workflowId,
+            workflowType: wf.workflowName,
+            ltType: wf.workflowName,
+            taskQueue,
+            signalId: `lt-standalone-${wf.workflowId}`,
+            parentWorkflowId: wf.workflowId,
+            originId,
+            parentId: envelope?.lt?.parentId,
+            envelope: JSON.stringify(envelope || {}),
+            traceId: wf.workflowTrace,
+            spanId: wf.workflowSpan,
+            initiatedBy: envelope?.lt?.initiatedBy ?? envelope?.lt?.userId,
+            executingAs: envelope?.lt?.initiatedBy ? envelope?.lt?.userId : undefined,
+        });
+        await activities.ltStartTask(taskId);
+    }
+    else if (existingTask?.status === 'pending') {
+        await activities.ltStartTask(taskId);
+    }
+    return { taskId, routing, originId };
+}
+/** Publish workflow.started + task.started events. */
+function publishStartedEvents(wf, taskQueue, taskId, originId) {
+    (0, publish_1.publishWorkflowEvent)({
+        type: 'workflow.started',
+        source: 'interceptor',
+        workflowId: wf.workflowId,
+        workflowName: wf.workflowName,
+        taskQueue,
+        taskId,
+        originId,
+        status: 'running',
+    });
+    (0, publish_1.publishTaskEvent)({
+        type: 'task.started',
+        source: 'interceptor',
+        workflowId: wf.workflowId,
+        workflowName: wf.workflowName,
+        taskQueue,
+        taskId: taskId,
+        originId,
+        status: 'in_progress',
+    });
+}
+/** Complete a task and signal parent for plain (non-LTReturn) results. */
+async function completePlainResult(activities, wf, taskQueue, taskId, routing, result) {
+    if (taskId) {
+        await activities.ltCompleteTask({
+            taskId,
+            data: JSON.stringify(result),
+            workflowId: wf.workflowId,
+            workflowName: wf.workflowName,
+            taskQueue,
+        });
+    }
+    if (routing?.parentWorkflowId && routing?.signalId) {
+        await activities.ltSignalParent({
+            parentTaskQueue: routing.parentTaskQueue,
+            parentWorkflowType: routing.parentWorkflowType,
+            parentWorkflowId: routing.parentWorkflowId,
+            signalId: routing.signalId,
+            data: result,
+        });
+    }
+}

package/build/services/interceptor/state.d.ts

@@ -0,0 +1,22 @@
+import type { LTEnvelope } from '../../types';
+import type * as interceptorActivities from './activities';
+import type { InterceptorState } from './types';
+/**
+ * The proxied activity functions available within the interceptor's
+ * workflow sandbox. Same shape as the activities module, but every
+ * call is routed through the durable activity worker.
+ */
+export type ProxiedActivities = typeof interceptorActivities;
+/**
+ * Build the stored envelope that preserves routing and task identity
+ * across escalation re-runs.
+ *
+ * When a human (or AI) resolves an escalation, a new workflow is
+ * started with this envelope — it carries the taskId and parent
+ * routing so the interceptor can reconnect the dots.
+ */
+export declare function buildStoredEnvelope(state: InterceptorState): Record<string, any>;
+/**
+ * Extract the LTEnvelope from the raw HotMesh workflow context.
+ */
+export declare function extractEnvelope(ctx: Map<string, any>): LTEnvelope | undefined;

package/build/services/interceptor/state.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStoredEnvelope = buildStoredEnvelope;
+exports.extractEnvelope = extractEnvelope;
+/**
+ * Build the stored envelope that preserves routing and task identity
+ * across escalation re-runs.
+ *
+ * When a human (or AI) resolves an escalation, a new workflow is
+ * started with this envelope — it carries the taskId and parent
+ * routing so the interceptor can reconnect the dots.
+ */
+function buildStoredEnvelope(state) {
+    return {
+        ...(state.envelope || {}),
+        lt: {
+            ...(state.envelope?.lt || {}),
+            taskId: state.taskId,
+            ...(state.routing?.parentWorkflowId
+                ? {
+                    signalId: state.routing.signalId,
+                    parentWorkflowId: state.routing.parentWorkflowId,
+                    parentTaskQueue: state.routing.parentTaskQueue,
+                    parentWorkflowType: state.routing.parentWorkflowType,
+                }
+                : {}),
+        },
+    };
+}
+/**
+ * Extract the LTEnvelope from the raw HotMesh workflow context.
+ */
+function extractEnvelope(ctx) {
+    const rawArgs = ctx.get('raw');
+    return rawArgs?.data?.arguments?.[0];
+}

package/build/services/interceptor/types.d.ts

@@ -0,0 +1,43 @@
+/** Shared type definitions for the interceptor module. */
+import type { LTEnvelope, LTResolvedConfig } from '../../types';
+import type { ProxiedActivities } from './state';
+/**
+ * Mutable state carried through a single interceptor execute() call.
+ * Populated incrementally as context is resolved, then passed to
+ * the escalation and completion submodules.
+ */
+export interface InterceptorState {
+    workflowId: string;
+    workflowName: string;
+    taskQueue: string;
+    wfConfig: LTResolvedConfig | null;
+    defaultRole: string;
+    taskId: string | undefined;
+    routing: Record<string, any> | null;
+    envelope: LTEnvelope | undefined;
+    isReRun: boolean;
+    activities: ProxiedActivities;
+    traceId?: string;
+    spanId?: string;
+}
+export interface OrchestratorContext {
+    workflowId: string;
+    taskQueue: string;
+    workflowType: string;
+    /** Identity of the user who initiated this workflow chain. */
+    userId?: string;
+}
+/** Identity fields extracted from the HotMesh workflow context. */
+export interface WorkflowIdentity {
+    workflowId: string;
+    workflowName: string;
+    workflowTopic: string;
+    workflowTrace: string | undefined;
+    workflowSpan: string | undefined;
+}
+/** Result of task + routing resolution. */
+export interface TaskContext {
+    taskId: string | undefined;
+    routing: Record<string, any> | null;
+    originId: string;
+}

package/build/services/interceptor/types.js

@@ -0,0 +1,3 @@
+"use strict";
+/** Shared type definitions for the interceptor module. */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/services/llm/detect.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Provider detection from model name strings.
+ */
+import type { ProviderName } from './types';
+/**
+ * Detect the LLM provider from a model name string.
+ *
+ * - gpt-*, o1-*, o3-*, o4-*, chatgpt-* → openai
+ * - claude-* → anthropic
+ * - everything else → openai-compatible (Groq, Together, local, etc.)
+ */
+export declare function detectProvider(model: string): ProviderName;
+/**
+ * Resolve the API key for a given provider.
+ */
+export declare function resolveApiKey(provider: ProviderName): string | undefined;

package/build/services/llm/detect.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Provider detection from model name strings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProvider = detectProvider;
+exports.resolveApiKey = resolveApiKey;
+/**
+ * Detect the LLM provider from a model name string.
+ *
+ * - gpt-*, o1-*, o3-*, o4-*, chatgpt-* → openai
+ * - claude-* → anthropic
+ * - everything else → openai-compatible (Groq, Together, local, etc.)
+ */
+function detectProvider(model) {
+    if (/^(gpt-|o1-|o3-|o4-|chatgpt-)/.test(model))
+        return 'openai';
+    if (/^claude-/.test(model))
+        return 'anthropic';
+    return 'openai-compatible';
+}
+/**
+ * Resolve the API key for a given provider.
+ */
+function resolveApiKey(provider) {
+    switch (provider) {
+        case 'openai':
+        case 'openai-compatible':
+            return process.env.LT_LLM_API_KEY || process.env.OPENAI_API_KEY;
+        case 'anthropic':
+            return process.env.ANTHROPIC_API_KEY;
+    }
+}

package/build/services/llm/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Model-agnostic LLM service.
+ *
+ * Single entry point for all LLM calls in the application.
+ * Automatically detects the provider from the model name and
+ * routes to the appropriate SDK (OpenAI, Anthropic, or any
+ * OpenAI-compatible provider).
+ *
+ * Usage:
+ *   import { callLLM, hasLLMApiKey } from '../services/llm';
+ *   const response = await callLLM({ model, messages, tools, max_tokens });
+ *   console.log(response.content, response.tool_calls);
+ */
+import type { LLMOptions, LLMResponse } from './types';
+export type { LLMOptions, LLMResponse, LLMProvider, ChatMessage, ToolDefinition, ToolCall, ContentPart, TextContent, ImageUrlContent, ProviderName, } from './types';
+export { detectProvider } from './detect';
+/**
+ * Call an LLM with model-agnostic options.
+ *
+ * The provider is auto-detected from the model name:
+ * - gpt-*, o1-*, o3-*, o4-* → OpenAI
+ * - claude-* → Anthropic
+ * - others → OpenAI-compatible (respects LT_LLM_BASE_URL)
+ *
+ * Messages, tools, and responses use OpenAI's format as the canonical
+ * representation. Translation to/from other providers happens internally.
+ */
+export declare function callLLM(options: LLMOptions): Promise<LLMResponse>;
+/**
+ * Check if the required API key is available for a given model.
+ * Useful for conditional feature enablement (e.g., skip LLM compilation
+ * when no key is configured).
+ */
+export declare function hasLLMApiKey(model?: string): boolean;

package/build/services/llm/index.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Model-agnostic LLM service.
+ *
+ * Single entry point for all LLM calls in the application.
+ * Automatically detects the provider from the model name and
+ * routes to the appropriate SDK (OpenAI, Anthropic, or any
+ * OpenAI-compatible provider).
+ *
+ * Usage:
+ *   import { callLLM, hasLLMApiKey } from '../services/llm';
+ *   const response = await callLLM({ model, messages, tools, max_tokens });
+ *   console.log(response.content, response.tool_calls);
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProvider = void 0;
+exports.callLLM = callLLM;
+exports.hasLLMApiKey = hasLLMApiKey;
+const detect_1 = require("./detect");
+var detect_2 = require("./detect");
+Object.defineProperty(exports, "detectProvider", { enumerable: true, get: function () { return detect_2.detectProvider; } });
+// ── Provider cache (lazy singletons) ──────────────────────────────────────────
+const providers = new Map();
+async function getProvider(model) {
+    const name = (0, detect_1.detectProvider)(model);
+    let provider = providers.get(name);
+    if (!provider) {
+        const apiKey = (0, detect_1.resolveApiKey)(name);
+        switch (name) {
+            case 'openai':
+            case 'openai-compatible': {
+                const { OpenAIProvider } = await Promise.resolve().then(() => __importStar(require('./providers/openai')));
+                const baseURL = process.env.LT_LLM_BASE_URL;
+                provider = new OpenAIProvider(apiKey, name === 'openai-compatible' ? baseURL : undefined);
+                break;
+            }
+            case 'anthropic': {
+                const { AnthropicProvider } = await Promise.resolve().then(() => __importStar(require('./providers/anthropic')));
+                provider = new AnthropicProvider(apiKey);
+                break;
+            }
+        }
+        providers.set(name, provider);
+    }
+    return provider;
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Call an LLM with model-agnostic options.
+ *
+ * The provider is auto-detected from the model name:
+ * - gpt-*, o1-*, o3-*, o4-* → OpenAI
+ * - claude-* → Anthropic
+ * - others → OpenAI-compatible (respects LT_LLM_BASE_URL)
+ *
+ * Messages, tools, and responses use OpenAI's format as the canonical
+ * representation. Translation to/from other providers happens internally.
+ */
+async function callLLM(options) {
+    const provider = await getProvider(options.model);
+    return provider.call(options);
+}
+/**
+ * Check if the required API key is available for a given model.
+ * Useful for conditional feature enablement (e.g., skip LLM compilation
+ * when no key is configured).
+ */
+function hasLLMApiKey(model) {
+    const m = model || process.env.LT_LLM_MODEL_PRIMARY || 'claude-sonnet-4-6';
+    const provider = (0, detect_1.detectProvider)(m);
+    const key = (0, detect_1.resolveApiKey)(provider);
+    return !!key && key !== 'xxx';
+}

package/build/services/llm/providers/anthropic.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Anthropic provider — translates OpenAI canonical format to Anthropic's API.
+ */
+import type { LLMOptions, LLMResponse, LLMProvider } from '../types';
+export declare class AnthropicProvider implements LLMProvider {
+    private clientPromise;
+    private apiKey;
+    constructor(apiKey?: string);
+    private getClient;
+    call(options: LLMOptions): Promise<LLMResponse>;
+}

package/build/services/llm/providers/anthropic.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Anthropic provider — translates OpenAI canonical format to Anthropic's API.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const translate_1 = require("../translate");
+const DEFAULT_MAX_TOKENS = 4096;
+class AnthropicProvider {
+    constructor(apiKey) {
+        this.clientPromise = null;
+        this.apiKey = apiKey || process.env.ANTHROPIC_API_KEY || '';
+        if (!this.apiKey) {
+            throw new Error('ANTHROPIC_API_KEY is required for Claude models. ' +
+                'Set it in your environment or .env file.');
+        }
+    }
+    async getClient() {
+        if (!this.clientPromise) {
+            this.clientPromise = Promise.resolve().then(() => __importStar(require('@anthropic-ai/sdk'))).then((mod) => new mod.default({ apiKey: this.apiKey }));
+        }
+        return this.clientPromise;
+    }
+    async call(options) {
+        const client = await this.getClient();
+        // Translate messages from OpenAI canonical to Anthropic format
+        const { system, messages } = (0, translate_1.translateMessagesToAnthropic)(options.messages);
+        // Build system prompt — append JSON mode instruction if needed
+        let systemPrompt = system;
+        if (options.response_format?.type === 'json_object') {
+            const jsonInstruction = '\n\nYou must respond with valid JSON only. No markdown fences, no explanation, just the JSON object.';
+            systemPrompt = systemPrompt ? systemPrompt + jsonInstruction : jsonInstruction.trim();
+        }
+        // Anthropic requires max_tokens
+        const maxTokens = options.max_tokens || DEFAULT_MAX_TOKENS;
+        // Build request
+        const request = {
+            model: options.model,
+            max_tokens: maxTokens,
+            messages,
+            ...(systemPrompt ? { system: systemPrompt } : {}),
+            ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+        };
+        // Translate tools
+        if (options.tools?.length) {
+            request.tools = (0, translate_1.translateToolsToAnthropic)(options.tools);
+        }
+        const response = await client.messages.create(request);
+        return (0, translate_1.translateAnthropicResponse)(response);
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;

package/build/services/llm/providers/openai.d.ts

@@ -0,0 +1,9 @@
+/**
+ * OpenAI provider — thin wrapper since our canonical format matches OpenAI's.
+ */
+import type { LLMOptions, LLMResponse, LLMProvider } from '../types';
+export declare class OpenAIProvider implements LLMProvider {
+    private client;
+    constructor(apiKey?: string, baseURL?: string);
+    call(options: LLMOptions): Promise<LLMResponse>;
+}

package/build/services/llm/providers/openai.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * OpenAI provider — thin wrapper since our canonical format matches OpenAI's.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const openai_1 = __importDefault(require("openai"));
+class OpenAIProvider {
+    constructor(apiKey, baseURL) {
+        this.client = new openai_1.default({
+            apiKey: apiKey || process.env.OPENAI_API_KEY,
+            ...(baseURL ? { baseURL } : {}),
+        });
+    }
+    async call(options) {
+        const response = await this.client.chat.completions.create({
+            model: options.model,
+            messages: options.messages,
+            ...(options.tools?.length ? { tools: options.tools } : {}),
+            ...(options.max_tokens !== undefined ? { max_tokens: options.max_tokens } : {}),
+            ...(options.temperature !== undefined ? { temperature: options.temperature } : {}),
+            ...(options.response_format ? { response_format: options.response_format } : {}),
+        });
+        const choice = response.choices[0]?.message;
+        if (!choice) {
+            return { content: null, tool_calls: undefined, usage: undefined };
+        }
+        return {
+            content: choice.content ?? null,
+            tool_calls: choice.tool_calls?.map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.function.name, arguments: tc.function.arguments },
+            })),
+            usage: response.usage ? {
+                prompt_tokens: response.usage.prompt_tokens,
+                completion_tokens: response.usage.completion_tokens,
+                total_tokens: response.usage.total_tokens,
+            } : undefined,
+        };
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;