@agentick/core 0.0.1

package/dist/model/simple-adapter.js

@@ -0,0 +1,264 @@
+/**
+ * Simple Adapter - Minimal API for creating model adapters
+ *
+ * This provides the simplest possible API for creating adapters.
+ * Adapters only need to implement:
+ * 1. prepareInput - convert engine input to provider format
+ * 2. mapChunk - convert provider chunk to AdapterDelta
+ * 3. execute/executeStream - call the provider
+ *
+ * The framework handles everything else (accumulation, events, etc.).
+ *
+ * @module tentickle/model/simple-adapter
+ */
+import { createLanguageModel } from "./model";
+import { StreamAccumulator, createChunkMapper, } from "./stream-accumulator";
+import { fromEngineState, toEngineState } from "./utils/language-model";
+// ============================================================================
+// Factory Functions
+// ============================================================================
+/**
+ * Create an adapter with the simplest possible API.
+ *
+ * This wraps createLanguageModel with sensible defaults:
+ * - Uses StreamAccumulator for stream handling (no manual accumulation)
+ * - Uses default fromEngineState/toEngineState (standard transformations)
+ * - Automatically generates StreamEvents from AdapterDeltas
+ *
+ * @example
+ * ```typescript
+ * import { createSimpleAdapter, StopReason } from '@tentickle/core/model';
+ * import { openai } from '@ai-sdk/openai';
+ *
+ * const model = createSimpleAdapter({
+ *   metadata: {
+ *     id: 'ai-sdk:gpt-4',
+ *     provider: 'ai-sdk',
+ *     capabilities: [{ stream: true, toolCalls: true }],
+ *   },
+ *
+ *   prepareInput: (input) => ({
+ *     model: openai('gpt-4'),
+ *     messages: toAiSdkMessages(input.messages),
+ *     tools: convertToolsToToolSet(input.tools),
+ *   }),
+ *
+ *   mapChunk: (chunk) => {
+ *     switch (chunk.type) {
+ *       case 'text-delta': return { type: 'text', delta: chunk.text };
+ *       case 'reasoning-delta': return { type: 'reasoning', delta: chunk.text };
+ *       case 'tool-call': return { type: 'tool_call', id: chunk.toolCallId, name: chunk.toolName, input: chunk.args };
+ *       case 'finish': return { type: 'message_end', stopReason: StopReason.STOP, usage: chunk.totalUsage };
+ *       default: return null;
+ *     }
+ *   },
+ *
+ *   execute: (input) => generateText(input),
+ *   executeStream: (input) => streamText(input).fullStream,
+ * });
+ * ```
+ */
+export function createSimpleAdapter(options) {
+    const { metadata, prepareInput, mapChunk, execute, executeStream, processOutput } = options;
+    return createLanguageModel({
+        metadata,
+        transformers: {
+            prepareInput,
+            processOutput: processOutput
+                ? processOutput
+                : // If no processOutput, we'll use streaming and accumulate
+                    undefined,
+            processChunk: (chunk) => {
+                // This won't be called directly when using StreamAccumulator
+                // but createLanguageModel requires it for backward compatibility
+                const delta = mapChunk(chunk);
+                if (!delta) {
+                    // Return a no-op event for ignored chunks
+                    return {
+                        type: "content_delta",
+                        id: `ignored_${Date.now()}`,
+                        tick: 1,
+                        timestamp: new Date().toISOString(),
+                        blockType: "text",
+                        blockIndex: 0,
+                        delta: "",
+                    };
+                }
+                // For simple cases, create basic events
+                // The real work is done in the custom stream handler below
+                return createBasicEvent(delta);
+            },
+            // processStream aggregates events into ModelOutput (fallback path)
+            processStream: (async (events) => {
+                let text = "";
+                const toolCalls = [];
+                let stopReason = "unspecified";
+                const usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+                for (const event of events) {
+                    if (event.type === "content_delta" && "delta" in event) {
+                        text += event.delta;
+                    }
+                    if (event.type === "tool_call" && "callId" in event) {
+                        const tc = event;
+                        toolCalls.push({
+                            id: tc.callId,
+                            name: tc.name,
+                            input: tc.input || {},
+                        });
+                    }
+                    if (event.type === "message_end" && "usage" in event) {
+                        const endEvent = event;
+                        if (endEvent.usage) {
+                            usage.inputTokens = endEvent.usage.inputTokens || 0;
+                            usage.outputTokens = endEvent.usage.outputTokens || 0;
+                            usage.totalTokens = endEvent.usage.totalTokens || 0;
+                        }
+                        stopReason = endEvent.stopReason;
+                    }
+                }
+                return {
+                    model: metadata.id,
+                    createdAt: new Date().toISOString(),
+                    message: { role: "assistant", content: [{ type: "text", text }] },
+                    messages: [{ role: "assistant", content: [{ type: "text", text }] }],
+                    usage,
+                    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                    stopReason,
+                    raw: events,
+                };
+            }), // Cast needed due to TChunk generic
+        },
+        executors: {
+            execute: async (input) => {
+                const result = await execute(input);
+                return result;
+            },
+            // executeStream wraps provider stream with StreamAccumulator
+            executeStream: executeStream
+                ? ((input) => {
+                    return createAccumulatedStream(executeStream(input), mapChunk, metadata.id);
+                }) // Cast needed: we return StreamEvent, not TChunk
+                : undefined,
+        },
+        fromEngineState: options.fromEngineState
+            ? async (input) => options.fromEngineState(input)
+            : async (input) => {
+                // Use default transformation with model metadata for config
+                const modelInstance = { metadata };
+                return fromEngineState(input, undefined, modelInstance);
+            },
+        toEngineState: options.toEngineState
+            ? async (output) => options.toEngineState(output)
+            : (output) => toEngineState(output),
+    });
+}
+/**
+ * Create an adapter using declarative chunk mapping.
+ *
+ * This is even simpler than createSimpleAdapter for cases where
+ * chunk mapping can be expressed declaratively.
+ *
+ * @example
+ * ```typescript
+ * const model = createDeclarativeAdapter({
+ *   metadata: { id: 'my-model', ... },
+ *   prepareInput: (input) => ({ ... }),
+ *   execute: (input) => provider.call(input),
+ *   executeStream: (input) => provider.stream(input),
+ *   chunkMapping: {
+ *     text: { type: 'text-delta', extract: (c) => c.text },
+ *     toolCall: { type: 'tool-call', extract: (c) => ({ id: c.id, name: c.name, input: c.args }) },
+ *     messageEnd: { type: 'finish', extract: (c) => ({ stopReason: StopReason.STOP }) },
+ *   },
+ * });
+ * ```
+ */
+export function createDeclarativeAdapter(options) {
+    const { chunkMapping, ...rest } = options;
+    const mapChunk = createChunkMapper(chunkMapping);
+    return createSimpleAdapter({
+        ...rest,
+        mapChunk,
+    });
+}
+// ============================================================================
+// Internal Helpers
+// ============================================================================
+/**
+ * Create a basic StreamEvent from an AdapterDelta.
+ * Used for backward compatibility with createLanguageModel.
+ */
+function createBasicEvent(delta) {
+    const base = {
+        id: `evt_${Date.now()}`,
+        tick: 1,
+        timestamp: new Date().toISOString(),
+    };
+    switch (delta.type) {
+        case "text":
+            return {
+                type: "content_delta",
+                ...base,
+                blockType: "text",
+                blockIndex: 0,
+                delta: delta.delta,
+            };
+        case "reasoning":
+            return { type: "reasoning_delta", ...base, blockIndex: 0, delta: delta.delta };
+        case "tool_call":
+            return {
+                type: "tool_call",
+                ...base,
+                callId: delta.id,
+                name: delta.name,
+                input: delta.input,
+                blockIndex: 0,
+                startedAt: base.timestamp,
+                completedAt: base.timestamp,
+            };
+        case "message_start":
+            return { type: "message_start", ...base, role: "assistant" };
+        case "message_end":
+            return {
+                type: "message_end",
+                ...base,
+                stopReason: delta.stopReason,
+                usage: delta.usage,
+            };
+        case "error":
+            return {
+                type: "error",
+                ...base,
+                error: {
+                    message: typeof delta.error === "string" ? delta.error : delta.error.message,
+                    code: delta.code,
+                },
+            };
+        default:
+            return {
+                type: "content_delta",
+                ...base,
+                blockType: "text",
+                blockIndex: 0,
+                delta: "",
+            };
+    }
+}
+/**
+ * Create an async iterable that uses StreamAccumulator to process chunks.
+ */
+async function* createAccumulatedStream(providerStream, mapChunk, modelId) {
+    const accumulator = new StreamAccumulator({ modelId });
+    for await (const chunk of providerStream) {
+        const delta = mapChunk(chunk);
+        if (delta) {
+            const events = accumulator.push(delta);
+            for (const event of events) {
+                yield event;
+            }
+        }
+    }
+    // If we never got a message_end, emit one now with accumulated content
+    // This handles providers that don't send explicit end events
+}
+//# sourceMappingURL=simple-adapter.js.map

package/dist/model/simple-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-adapter.js","sourceRoot":"","sources":["../../src/model/simple-adapter.ts"],"names":[],"mappings":"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"}

package/dist/model/stream-accumulator.d.ts

@@ -0,0 +1,284 @@
+/**
+ * StreamAccumulator - Framework-provided stream accumulation
+ *
+ * This handles the common pattern of accumulating stream deltas into
+ * a final ModelOutput. Adapters only need to map provider chunks to
+ * AdapterDelta - the accumulator handles the rest.
+ *
+ * @module agentick/model/stream-accumulator
+ */
+import type { UsageStats } from "@agentick/shared";
+import { StopReason } from "@agentick/shared";
+import type { StreamEvent, ContentMetadata } from "@agentick/shared/streaming";
+import type { ModelOutput } from "./model";
+/**
+ * AdapterDelta is the minimal interface adapters need to implement.
+ * Each provider chunk maps to one of these simple delta types.
+ *
+ * The framework's StreamAccumulator handles:
+ * - Accumulating text/reasoning into full strings
+ * - Building tool call objects from start/delta/end events
+ * - Emitting proper StreamEvents
+ * - Producing final ModelOutput
+ *
+ * @example
+ * ```typescript
+ * // AI SDK chunk → AdapterDelta
+ * function mapChunk(chunk: AiSdkChunk): AdapterDelta | null {
+ *   switch (chunk.type) {
+ *     case 'text-delta':
+ *       return { type: 'text', delta: chunk.text };
+ *     case 'tool-input-start':
+ *       return { type: 'tool_call_start', id: chunk.id, name: chunk.toolName };
+ *     case 'tool-input-delta':
+ *       return { type: 'tool_call_delta', id: chunk.id, delta: chunk.delta };
+ *     case 'finish':
+ *       return { type: 'message_end', stopReason: mapStopReason(chunk.finishReason) };
+ *     default:
+ *       return null; // Ignore unknown chunks
+ *   }
+ * }
+ * ```
+ */
+/**
+ * AdapterDelta is a simplified interface for adapter authors.
+ *
+ * Adapters map provider chunks to these simple delta types.
+ * The StreamAccumulator handles converting them into the full
+ * StreamEvent lifecycle (start/delta/end/complete patterns).
+ *
+ * For example, when an adapter emits { type: "text", delta: "Hello" },
+ * the accumulator automatically:
+ * - Emits content_start on first text
+ * - Emits content_delta for each text
+ * - Emits content_end when the block ends
+ *
+ * This keeps adapter code simple - no lifecycle tracking needed.
+ */
+export type AdapterDelta = {
+    type: "text";
+    delta: string;
+    metadata?: ContentMetadata;
+} | {
+    type: "reasoning";
+    delta: string;
+    metadata?: ContentMetadata;
+} | {
+    type: "tool_call_start";
+    id: string;
+    name: string;
+} | {
+    type: "tool_call_delta";
+    id: string;
+    delta: string;
+} | {
+    type: "tool_call_end";
+    id: string;
+    input: unknown;
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: "message_start";
+    model?: string;
+} | {
+    type: "message_end";
+    stopReason: StopReason;
+    usage?: UsageStats;
+} | {
+    type: "usage";
+    usage: Partial<UsageStats>;
+} | {
+    type: "error";
+    error: Error | string;
+    code?: string;
+} | {
+    type: "raw";
+    data: unknown;
+} | {
+    type: "content_metadata";
+    metadata: ContentMetadata;
+} | {
+    type: "reasoning_metadata";
+    metadata: ContentMetadata;
+};
+/**
+ * Options for StreamAccumulator.
+ */
+export interface StreamAccumulatorOptions {
+    /** Model ID for events */
+    modelId?: string;
+    /** Current tick number */
+    tick?: number;
+}
+/**
+ * StreamAccumulator handles the common pattern of accumulating stream
+ * deltas into a final ModelOutput.
+ *
+ * Usage:
+ * 1. Create accumulator at stream start
+ * 2. For each provider chunk, call accumulator.push(mapChunk(chunk))
+ * 3. accumulator.push() yields StreamEvent(s) to emit
+ * 4. After stream ends, call accumulator.toModelOutput()
+ *
+ * @example
+ * ```typescript
+ * const accumulator = new StreamAccumulator({ modelId: 'gpt-4' });
+ *
+ * for await (const chunk of providerStream) {
+ *   const delta = mapChunk(chunk);
+ *   if (delta) {
+ *     for (const event of accumulator.push(delta)) {
+ *       yield event;
+ *     }
+ *   }
+ * }
+ *
+ * return accumulator.toModelOutput();
+ * ```
+ */
+export declare class StreamAccumulator {
+    private readonly options;
+    private text;
+    private reasoning;
+    private toolCalls;
+    private completedToolCalls;
+    private usage;
+    private stopReason;
+    private modelId?;
+    private contentMetadata?;
+    private reasoningMetadata?;
+    private messageStarted;
+    private messageStartedAt?;
+    private textStarted;
+    private reasoningStarted;
+    private blockIndex;
+    constructor(options?: StreamAccumulatorOptions);
+    /**
+     * Process an AdapterDelta and return StreamEvent(s) to emit.
+     *
+     * Most deltas produce a single event, but some (like message_end)
+     * may produce multiple events.
+     */
+    push(delta: AdapterDelta): StreamEvent[];
+    /**
+     * Get the accumulated content as a final ModelOutput.
+     * Call this after the stream has ended.
+     */
+    toModelOutput(): ModelOutput;
+    /**
+     * Get accumulated text (for mid-stream access).
+     */
+    getText(): string;
+    /**
+     * Get accumulated reasoning (for mid-stream access).
+     */
+    getReasoning(): string;
+    /**
+     * Parse accumulated JSON string to object.
+     */
+    private parseToolInput;
+    /**
+     * Merge metadata objects, concatenating arrays and merging objects.
+     */
+    private mergeMetadata;
+}
+/**
+ * ChunkMapping defines how to extract AdapterDelta from a provider chunk.
+ * This is syntactic sugar for simple cases where the mapping is declarative.
+ *
+ * @example
+ * ```typescript
+ * const aiSdkMapping: ChunkMapping<AiSdkChunk> = {
+ *   text: { type: 'text-delta', extract: (c) => c.text },
+ *   reasoning: { type: 'reasoning-delta', extract: (c) => c.text },
+ *   toolCallStart: { type: 'tool-input-start', extract: (c) => ({ id: c.id, name: c.toolName }) },
+ *   toolCallDelta: { type: 'tool-input-delta', extract: (c) => ({ id: c.id, delta: c.delta }) },
+ *   toolCallEnd: { type: 'tool-input-end', extract: (c) => ({ id: c.id }) },
+ *   messageStart: { type: 'start', extract: () => ({}) },
+ *   messageEnd: { type: 'finish', extract: (c) => ({ stopReason: mapStopReason(c.finishReason), usage: c.totalUsage }) },
+ * };
+ * ```
+ */
+export interface ChunkMapping<TChunk> {
+    text?: {
+        type: string;
+        extract: (chunk: TChunk) => string;
+    };
+    reasoning?: {
+        type: string;
+        extract: (chunk: TChunk) => string;
+    };
+    toolCallStart?: {
+        type: string;
+        extract: (chunk: TChunk) => {
+            id: string;
+            name: string;
+        };
+    };
+    toolCallDelta?: {
+        type: string;
+        extract: (chunk: TChunk) => {
+            id: string;
+            delta: string;
+        };
+    };
+    toolCallEnd?: {
+        type: string;
+        extract: (chunk: TChunk) => {
+            id: string;
+            input?: unknown;
+        };
+    };
+    toolCall?: {
+        type: string;
+        extract: (chunk: TChunk) => {
+            id: string;
+            name: string;
+            input: unknown;
+        };
+    };
+    messageStart?: {
+        type: string;
+        extract: (chunk: TChunk) => {
+            model?: string;
+        };
+    };
+    messageEnd?: {
+        type: string;
+        extract: (chunk: TChunk) => {
+            stopReason: StopReason;
+            usage?: UsageStats;
+        };
+    };
+    usage?: {
+        type: string;
+        extract: (chunk: TChunk) => Partial<UsageStats>;
+    };
+    error?: {
+        type: string;
+        extract: (chunk: TChunk) => {
+            error: Error | string;
+            code?: string;
+        };
+    };
+}
+/**
+ * Create a mapChunk function from a declarative ChunkMapping.
+ *
+ * @example
+ * ```typescript
+ * const mapChunk = createChunkMapper(aiSdkMapping);
+ *
+ * for await (const chunk of stream) {
+ *   const delta = mapChunk(chunk);
+ *   if (delta) yield* accumulator.push(delta);
+ * }
+ * ```
+ */
+export declare function createChunkMapper<TChunk extends {
+    type: string;
+}>(mapping: ChunkMapping<TChunk>): (chunk: TChunk) => AdapterDelta | null;
+//# sourceMappingURL=stream-accumulator.d.ts.map

package/dist/model/stream-accumulator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-accumulator.d.ts","sourceRoot":"","sources":["../../src/model/stream-accumulator.ts"],"names":[],"mappings":"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"}