agentic-kit 0.3.0 → 1.2.0

package/messages.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmptyUsage = createEmptyUsage;
+exports.calculateUsageCost = calculateUsageCost;
+exports.createAssistantMessage = createAssistantMessage;
+exports.createTextContent = createTextContent;
+exports.createImageContent = createImageContent;
+exports.createToolCall = createToolCall;
+exports.createUserMessage = createUserMessage;
+exports.createToolResultMessage = createToolResultMessage;
+exports.getMessageText = getMessageText;
+exports.injectDeferralResults = injectDeferralResults;
+exports.cloneMessage = cloneMessage;
+exports.normalizeContext = normalizeContext;
+function createEmptyUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 0,
+        },
+    };
+}
+function calculateUsageCost(model, usage) {
+    const schedule = model.cost;
+    usage.cost.input = ((schedule?.input ?? 0) / 1_000_000) * usage.input;
+    usage.cost.output = ((schedule?.output ?? 0) / 1_000_000) * usage.output;
+    usage.cost.cacheRead = ((schedule?.cacheRead ?? 0) / 1_000_000) * usage.cacheRead;
+    usage.cost.cacheWrite = ((schedule?.cacheWrite ?? 0) / 1_000_000) * usage.cacheWrite;
+    usage.cost.total =
+        usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+    return usage.cost;
+}
+function createAssistantMessage(model) {
+    return {
+        role: 'assistant',
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        content: [],
+        usage: createEmptyUsage(),
+        stopReason: 'stop',
+        timestamp: Date.now(),
+    };
+}
+function createTextContent(text = '') {
+    return { type: 'text', text };
+}
+function createImageContent(data, mimeType) {
+    return { type: 'image', data, mimeType };
+}
+function createToolCall(id, name) {
+    return { type: 'toolCall', id, name, arguments: {}, rawArguments: '' };
+}
+function createUserMessage(content) {
+    return {
+        role: 'user',
+        content,
+        timestamp: Date.now(),
+    };
+}
+function createToolResultMessage(toolCallId, toolName, content, isError = false) {
+    return {
+        role: 'toolResult',
+        toolCallId,
+        toolName,
+        content,
+        isError,
+        timestamp: Date.now(),
+    };
+}
+function getMessageText(message) {
+    return message.content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('');
+}
+const DEFAULT_DEFERRAL_TEXT = 'User did not respond. Continue.';
+/**
+ * Synthesize toolResult messages for every toolCall that lacks both a decision
+ * and a paired toolResult. Returns input unchanged (referentially equal) when
+ * nothing needs synthesizing.
+ *
+ * Use case: user types a message instead of clicking approve/deny on a paused
+ * tool. The agent can't resume on text alone — every dangling toolCall needs
+ * a result before the next request. Compose with sendMessages to forward the
+ * conversation cleanly:
+ *
+ *   await sendMessages([...injectDeferralResults(messages), createUserMessage(text)]);
+ */
+function injectDeferralResults(messages, optionsOrText = {}) {
+    const opts = typeof optionsOrText === 'string' ? { deferralText: optionsOrText } : optionsOrText;
+    const deferralText = opts.deferralText ?? DEFAULT_DEFERRAL_TEXT;
+    const completed = new Set();
+    for (const m of messages) {
+        if (m.role === 'toolResult')
+            completed.add(m.toolCallId);
+    }
+    const synthetic = [];
+    for (const m of messages) {
+        if (m.role !== 'assistant')
+            continue;
+        for (const block of m.content) {
+            if (block.type !== 'toolCall')
+                continue;
+            if (completed.has(block.id))
+                continue;
+            if ('decision' in block && block.decision !== undefined)
+                continue;
+            const result = createToolResultMessage(block.id, block.name, [
+                { type: 'text', text: deferralText },
+            ]);
+            if (opts.details !== undefined)
+                result.details = opts.details;
+            synthetic.push(result);
+        }
+    }
+    if (synthetic.length === 0)
+        return messages;
+    return [...messages, ...synthetic];
+}
+function cloneMessage(message) {
+    return JSON.parse(JSON.stringify(message));
+}
+function normalizeContext(context) {
+    return {
+        systemPrompt: context.systemPrompt,
+        tools: context.tools ?? [],
+        messages: context.messages.map((message) => ensureTimestamp(cloneMessage(message))),
+    };
+}
+function ensureTimestamp(message) {
+    if (typeof message.timestamp !== 'number') {
+        message.timestamp = Date.now();
+    }
+    return message;
+}

package/model-registry.d.ts

@@ -0,0 +1,7 @@
+import type { ModelDescriptor } from './types.js';
+export declare function registerModel(model: ModelDescriptor): void;
+export declare function registerModels(models: ModelDescriptor[]): void;
+export declare function getModel(provider: string, modelId: string): ModelDescriptor | undefined;
+export declare function getModels(provider?: string): ModelDescriptor[];
+export declare function getProviders(): string[];
+export declare function clearModels(): void;

package/model-registry.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerModel = registerModel;
+exports.registerModels = registerModels;
+exports.getModel = getModel;
+exports.getModels = getModels;
+exports.getProviders = getProviders;
+exports.clearModels = clearModels;
+const modelsByProvider = new Map();
+function registerModel(model) {
+    const providerModels = modelsByProvider.get(model.provider) ?? new Map();
+    providerModels.set(model.id, model);
+    modelsByProvider.set(model.provider, providerModels);
+}
+function registerModels(models) {
+    for (const model of models) {
+        registerModel(model);
+    }
+}
+function getModel(provider, modelId) {
+    return modelsByProvider.get(provider)?.get(modelId);
+}
+function getModels(provider) {
+    if (provider) {
+        return Array.from(modelsByProvider.get(provider)?.values() ?? []);
+    }
+    return Array.from(modelsByProvider.values()).flatMap((entries) => Array.from(entries.values()));
+}
+function getProviders() {
+    return Array.from(modelsByProvider.keys());
+}
+function clearModels() {
+    modelsByProvider.clear();
+}

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "agentic-kit",
-  "version": "0.3.0",
+  "version": "1.2.0",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "Provider-agnostic LLM adapter with streaming and multi-turn support",
   "main": "index.js",
   "module": "esm/index.js",
   "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    }
+  },
   "homepage": "https://github.com/constructive-io/agentic-kit",
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {
@@ -21,19 +28,19 @@
   },
   "scripts": {
     "clean": "makage clean",
+    "prepack": "npm run build",
     "build": "makage build",
+    "postbuild": "node ../../scripts/write-esm-package-json.js",
     "build:dev": "makage build --dev",
     "lint": "eslint . --fix",
     "test": "jest",
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "@agentic-kit/anthropic": "workspace:*",
-    "@agentic-kit/ollama": "workspace:*",
-    "@agentic-kit/openai": "workspace:*"
-  },
-  "devDependencies": {
-    "cross-fetch": "^4.1.0"
+    "@agentic-kit/anthropic": "1.2.0",
+    "@agentic-kit/ollama": "1.2.0",
+    "@agentic-kit/openai": "1.2.0"
   },
-  "keywords": []
+  "keywords": [],
+  "gitHead": "d4f3f660be621267efe12671c22db202ccdb3f0b"
 }

package/provider-registry.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderAdapter } from './types.js';
+export declare function registerProvider(adapter: ProviderAdapter, sourceId?: string): void;
+export declare function getProvider(api: string): ProviderAdapter | undefined;
+export declare function getProviders(): ProviderAdapter[];
+export declare function unregisterProviders(sourceId: string): void;
+export declare function clearProviders(): void;

package/provider-registry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerProvider = registerProvider;
+exports.getProvider = getProvider;
+exports.getProviders = getProviders;
+exports.unregisterProviders = unregisterProviders;
+exports.clearProviders = clearProviders;
+const providersByApi = new Map();
+function registerProvider(adapter, sourceId) {
+    providersByApi.set(adapter.api, { adapter, sourceId });
+}
+function getProvider(api) {
+    return providersByApi.get(api)?.adapter;
+}
+function getProviders() {
+    return Array.from(providersByApi.values(), (entry) => entry.adapter);
+}
+function unregisterProviders(sourceId) {
+    for (const [api, entry] of providersByApi.entries()) {
+        if (entry.sourceId === sourceId) {
+            providersByApi.delete(api);
+        }
+    }
+}
+function clearProviders() {
+    providersByApi.clear();
+}

package/transform-messages.d.ts

@@ -0,0 +1,2 @@
+import type { Message, ModelDescriptor } from './types.js';
+export declare function transformMessages(messages: Message[], model: ModelDescriptor): Message[];

package/transform-messages.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformMessages = transformMessages;
+function transformMessages(messages, model) {
+    const toolCallIdMap = new Map();
+    const transformed = messages.flatMap((message) => {
+        if (message.role !== 'assistant') {
+            if (message.role === 'toolResult') {
+                const normalizedId = toolCallIdMap.get(message.toolCallId);
+                if (normalizedId && normalizedId !== message.toolCallId) {
+                    return [{ ...message, toolCallId: normalizedId }];
+                }
+            }
+            return [message];
+        }
+        if (message.stopReason === 'error' || message.stopReason === 'aborted') {
+            return [];
+        }
+        const sameModel = message.provider === model.provider &&
+            message.api === model.api &&
+            message.model === model.id;
+        const content = message.content.flatMap((block) => {
+            if (block.type === 'thinking') {
+                if (sameModel) {
+                    return [block];
+                }
+                if (!block.thinking.trim()) {
+                    return [];
+                }
+                const thinkingAsText = {
+                    type: 'text',
+                    text: `<thinking>${block.thinking}</thinking>`,
+                };
+                return [thinkingAsText];
+            }
+            if (block.type === 'toolCall') {
+                const normalizedId = normalizeToolCallId(block.id, model);
+                if (normalizedId !== block.id) {
+                    toolCallIdMap.set(block.id, normalizedId);
+                }
+                const toolCall = normalizedId === block.id ? block : { ...block, id: normalizedId };
+                return [toolCall];
+            }
+            return [block];
+        });
+        return [{ ...message, content }];
+    });
+    return insertSyntheticToolResults(transformed);
+}
+function insertSyntheticToolResults(messages) {
+    const result = [];
+    let pendingToolCalls = [];
+    let seenToolResults = new Set();
+    for (const message of messages) {
+        if (message.role === 'assistant') {
+            flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
+            pendingToolCalls = message.content.filter((block) => block.type === 'toolCall');
+            seenToolResults = new Set();
+            result.push(message);
+            continue;
+        }
+        if (message.role === 'toolResult') {
+            seenToolResults.add(message.toolCallId);
+            result.push(message);
+            continue;
+        }
+        flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
+        pendingToolCalls = [];
+        seenToolResults = new Set();
+        result.push(message);
+    }
+    flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
+    return result;
+}
+function flushPendingToolCalls(result, pendingToolCalls, seenToolResults) {
+    if (pendingToolCalls.length === 0) {
+        return;
+    }
+    for (const toolCall of pendingToolCalls) {
+        if (seenToolResults.has(toolCall.id)) {
+            continue;
+        }
+        const synthetic = {
+            role: 'toolResult',
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: [{ type: 'text', text: 'No result provided.' }],
+            isError: true,
+            timestamp: Date.now(),
+        };
+        result.push(synthetic);
+    }
+}
+function normalizeToolCallId(id, model) {
+    const format = model.compat?.toolCallIdFormat ?? defaultToolCallIdFormat(model);
+    if (format === 'passthrough') {
+        return id;
+    }
+    if (format === 'mistral9') {
+        const alphanumeric = id.replace(/[^a-zA-Z0-9]/g, '');
+        if (alphanumeric.length >= 9) {
+            return alphanumeric.slice(0, 9);
+        }
+        return stableAlphanumericId(id, 9);
+    }
+    const safe = id.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+    if (safe.length > 0) {
+        return safe;
+    }
+    return stableId(id, 24, /^[a-zA-Z0-9_-]+$/);
+}
+function defaultToolCallIdFormat(model) {
+    if (model.provider === 'anthropic' || model.api === 'anthropic-messages') {
+        return 'safe64';
+    }
+    return 'passthrough';
+}
+function stableId(input, length, pattern) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i += 1) {
+        hash = (hash * 31 + input.charCodeAt(i)) >>> 0;
+    }
+    let value = `tc_${hash.toString(36)}`;
+    while (!pattern.test(value)) {
+        value = value.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+    if (value.length >= length) {
+        return value.slice(0, length);
+    }
+    return value.padEnd(length, '0');
+}
+function stableAlphanumericId(input, length) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i += 1) {
+        hash = (hash * 31 + input.charCodeAt(i)) >>> 0;
+    }
+    const value = `tc${hash.toString(36)}`.replace(/[^a-zA-Z0-9]/g, '');
+    if (value.length >= length) {
+        return value.slice(0, length);
+    }
+    return value.padEnd(length, '0');
+}

package/types.d.ts

@@ -0,0 +1,231 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+export interface JsonObject {
+    [key: string]: JsonValue | undefined;
+}
+export interface JsonSchema {
+    $id?: string;
+    $ref?: string;
+    additionalProperties?: boolean | JsonSchema;
+    allOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    const?: JsonValue;
+    default?: JsonValue;
+    description?: string;
+    enum?: JsonValue[];
+    format?: string;
+    items?: JsonSchema | JsonSchema[];
+    maxItems?: number;
+    maxLength?: number;
+    maximum?: number;
+    minItems?: number;
+    minLength?: number;
+    minimum?: number;
+    oneOf?: JsonSchema[];
+    pattern?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    title?: string;
+    type?: string | string[];
+}
+export type InputCapability = 'text' | 'image';
+export interface CostSchedule {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+}
+export interface OpenAICompatibleCompat {
+    maxTokensField?: 'max_completion_tokens' | 'max_tokens';
+    reasoningFormat?: 'none' | 'openai';
+    supportsReasoningEffort?: boolean;
+    supportsStrictToolSchema?: boolean;
+    supportsUsageInStreaming?: boolean;
+    toolCallIdFormat?: 'passthrough' | 'safe64' | 'mistral9';
+    requiresToolResultName?: boolean;
+}
+export interface ModelDescriptor {
+    id: string;
+    name: string;
+    api: string;
+    provider: string;
+    baseUrl: string;
+    input: InputCapability[];
+    reasoning: boolean;
+    tools?: boolean;
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    cost?: CostSchedule;
+    headers?: Record<string, string>;
+    compat?: OpenAICompatibleCompat;
+}
+export interface TextContent {
+    type: 'text';
+    text: string;
+}
+export interface ImageContent {
+    type: 'image';
+    data: string;
+    mimeType: string;
+}
+export interface ThinkingContent {
+    type: 'thinking';
+    thinking: string;
+    signature?: string;
+}
+export interface ToolCallContent {
+    type: 'toolCall';
+    id: string;
+    name: string;
+    arguments: Record<string, JsonValue | undefined>;
+    rawArguments?: string;
+    decision?: unknown;
+}
+export interface Usage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    totalTokens: number;
+    cost: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+}
+export type StopReason = 'stop' | 'length' | 'toolUse' | 'error' | 'aborted';
+export interface UserMessage {
+    role: 'user';
+    content: string | Array<TextContent | ImageContent>;
+    timestamp: number;
+}
+export interface AssistantMessage {
+    role: 'assistant';
+    content: Array<TextContent | ThinkingContent | ToolCallContent>;
+    api: string;
+    provider: string;
+    model: string;
+    usage: Usage;
+    stopReason: StopReason;
+    errorMessage?: string;
+    timestamp: number;
+}
+export interface ToolResultMessage<TDetails = unknown> {
+    role: 'toolResult';
+    toolCallId: string;
+    toolName: string;
+    content: Array<TextContent | ImageContent>;
+    isError: boolean;
+    details?: TDetails;
+    timestamp: number;
+}
+export type Message = UserMessage | AssistantMessage | ToolResultMessage;
+export interface ToolDefinition<TSchema extends JsonSchema = JsonSchema> {
+    name: string;
+    description: string;
+    parameters: TSchema;
+}
+export interface Context {
+    systemPrompt?: string;
+    messages: Message[];
+    tools?: ToolDefinition[];
+}
+export type CacheRetention = 'none' | 'short' | 'long';
+export interface StreamOptions {
+    apiKey?: string;
+    cacheRetention?: CacheRetention;
+    headers?: Record<string, string>;
+    maxRetryDelayMs?: number;
+    maxTokens?: number;
+    metadata?: Record<string, JsonValue | undefined>;
+    onPayload?: (payload: unknown) => void;
+    reasoning?: 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+    sessionId?: string;
+    signal?: AbortSignal;
+    temperature?: number;
+}
+export type AssistantMessageEvent = {
+    type: 'start';
+    partial: AssistantMessage;
+} | {
+    type: 'text_start';
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: 'text_delta';
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: 'text_end';
+    contentIndex: number;
+    content: string;
+    partial: AssistantMessage;
+} | {
+    type: 'thinking_start';
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: 'thinking_delta';
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: 'thinking_end';
+    contentIndex: number;
+    content: string;
+    partial: AssistantMessage;
+} | {
+    type: 'toolcall_start';
+    contentIndex: number;
+    partial: AssistantMessage;
+} | {
+    type: 'toolcall_delta';
+    contentIndex: number;
+    delta: string;
+    partial: AssistantMessage;
+} | {
+    type: 'toolcall_end';
+    contentIndex: number;
+    toolCall: ToolCallContent;
+    partial: AssistantMessage;
+} | {
+    type: 'done';
+    reason: Extract<StopReason, 'stop' | 'length' | 'toolUse'>;
+    message: AssistantMessage;
+} | {
+    type: 'error';
+    reason: Extract<StopReason, 'error' | 'aborted'>;
+    error: AssistantMessage;
+};
+export interface ProviderAdapter<TOptions extends StreamOptions = StreamOptions> {
+    api: string;
+    provider: string;
+    createModel?: (modelId: string, overrides?: Partial<ModelDescriptor>) => ModelDescriptor;
+    listModels?: (options?: Pick<StreamOptions, 'apiKey' | 'headers'>) => Promise<Array<ModelDescriptor | string>>;
+    stream: (model: ModelDescriptor, context: Context, options?: TOptions) => AssistantMessageEventStream;
+}
+export interface LegacyChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface LegacyGenerateInput {
+    model: string;
+    prompt?: string;
+    messages?: LegacyChatMessage[];
+    system?: string;
+    stream?: boolean;
+    temperature?: number;
+    maxTokens?: number;
+}
+export interface LegacyStreamingOptions {
+    onChunk?: (chunk: string) => void;
+    onComplete?: () => void;
+    onError?: (error: Error) => void;
+    onStateChange?: (state: string) => void;
+}
+export interface AssistantMessageEventStream extends AsyncIterable<AssistantMessageEvent> {
+    result(): Promise<AssistantMessage>;
+}

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });