@agentic-kit/chat 1.11.0

package/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Constructive <developers@constructive.io>
+Copyright (c) 2020-present, Interweb, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,193 @@
+# @agentic-kit/chat
+
+<p align="center" width="100%">
+  <img height="250" src="https://raw.githubusercontent.com/constructive-io/constructive/refs/heads/main/assets/outline-logo.svg" />
+</p>
+
+<p align="center" width="100%">
+  <a href="https://github.com/constructive-io/agentic-kit/actions/workflows/run-tests.yaml">
+    <img height="20" src="https://github.com/constructive-io/agentic-kit/actions/workflows/run-tests.yaml/badge.svg" />
+  </a>
+   <a href="https://github.com/constructive-io/agentic-kit/blob/main/LICENSE"><img height="20" src="https://img.shields.io/badge/license-MIT-blue.svg"/></a>
+   <a href="https://www.npmjs.com/package/agentic-kit"><img height="20" src="https://img.shields.io/github/package-json/v/constructive-io/agentic-kit?filename=packages%2Fagentic-kit%2Fpackage.json"/></a>
+</p>
+
+A low-level provider portability layer for LLM applications. `agentic-kit`
+provides:
+
+- provider-independent `ModelDescriptor` and `Context` types
+- structured streaming events for text, reasoning, and tool calls
+- model and provider registries
+- cross-provider message normalization for replay and handoff
+- a one-release compatibility wrapper for the legacy `AgentKit.generate()` API
+
+## Installation
+
+```bash
+npm install agentic-kit
+```
+
+
+## Quick Start
+
+### Structured API
+
+```typescript
+import { complete, getModel } from 'agentic-kit';
+
+const model = getModel('openai', 'gpt-4o-mini');
+const message = await complete(model!, {
+  messages: [{ role: 'user', content: 'Hello', timestamp: Date.now() }],
+});
+
+console.log(message.content);
+```
+
+### Streaming
+
+```typescript
+import { stream, getModel } from 'agentic-kit';
+
+const model = getModel('openai', 'gpt-4o-mini');
+const result = stream(model!, {
+  messages: [{ role: 'user', content: 'Explain tool calling briefly.', timestamp: Date.now() }],
+});
+
+for await (const event of result) {
+  if (event.type === 'text_delta') {
+    process.stdout.write(event.delta);
+  }
+}
+```
+
+## API Reference
+
+### Core API
+
+- `stream(model: ModelDescriptor, context: Context, options?: StreamOptions)`
+- `complete(model: ModelDescriptor, context: Context, options?: StreamOptions)`
+- `completeText(model: ModelDescriptor, context: Context, options?: StreamOptions)`
+
+### Registry
+
+- `registerModel(model)`, `registerModels(models)`, `clearModels()`
+- `registerProvider(provider, sourceId?)`, `unregisterProviders(sourceId)`, `clearProviders()`
+- `getModel(provider, modelId)`, `getModels(provider?)`, `getModelProviders()`
+- `getProvider(api)`, `getRegisteredProviders()`
+
+The package pre-registers `OpenAIAdapter`, `AnthropicAdapter`, and
+`OllamaAdapter` (with empty credentials) plus the built-in model catalogs
+from each adapter package. Re-register an adapter with your own API key to
+activate it.
+
+### Message helpers
+
+- `createUserMessage(content)`, `createAssistantMessage(model)`,
+  `createToolResultMessage(toolCallId, toolName, content, isError?)`
+- `createTextContent(text?)`, `createImageContent(data, mimeType)`,
+  `createToolCall(id, name)`
+- `getMessageText(assistant)` — concatenate text blocks.
+- `cloneMessage(message)` — deep clone.
+- `normalizeContext(context)` — apply per-message normalization.
+- `injectDeferralResults(messages, options?)` — synthesize stand-in
+  `toolResult` messages for every `toolCall` that lacks both a decision and
+  a paired result. Useful when the user types a new message instead of
+  responding to a paused tool — the next request needs a well-formed
+  transcript.
+- `transformMessages(messages, model)` — cross-provider normalization for
+  replay across different providers.
+
+### Adapter re-exports
+
+- `OpenAIAdapter`, `AnthropicAdapter`, `OllamaAdapter`
+- Types: `OpenAIOptions`, `AnthropicOptions`
+- `OllamaClient` for direct Ollama HTTP access.
+
+### Legacy Compatibility API
+
+`AgentKit` is still available for one transition release:
+
+```ts
+interface GenerateInput {
+  model: string;
+  prompt?: string;
+  messages?: Array<{ role: 'system' | 'user' | 'assistant'; content: string }>;
+  stream?: boolean;
+}
+```
+
+Use `createOpenAIKit`, `createAnthropicKit`, `createOllamaKit`, or
+`createMultiProviderKit()` if you still need the old prompt-only entrypoint.
+
+---
+
+## Education and Tutorials
+
+ 1. 🚀 [Quickstart: Getting Up and Running](https://constructive.io/learn/quickstart)
+Get started with modular databases in minutes. Install prerequisites and deploy your first module.
+
+ 2. 📦 [Modular PostgreSQL Development with Database Packages](https://constructive.io/learn/modular-postgres)
+Learn to organize PostgreSQL projects with pgpm workspaces and reusable database modules.
+
+ 3. ✏️ [Authoring Database Changes](https://constructive.io/learn/authoring-database-changes)
+Master the workflow for adding, organizing, and managing database changes with pgpm.
+
+ 4. 🧪 [End-to-End PostgreSQL Testing with TypeScript](https://constructive.io/learn/e2e-postgres-testing)
+Master end-to-end PostgreSQL testing with ephemeral databases, RLS testing, and CI/CD automation.
+
+ 5. ⚡ [Supabase Testing](https://constructive.io/learn/supabase)
+Use TypeScript-first tools to test Supabase projects with realistic RLS, policies, and auth contexts.
+
+ 6. 💧 [Drizzle ORM Testing](https://constructive.io/learn/drizzle-testing)
+Run full-stack tests with Drizzle ORM, including database setup, teardown, and RLS enforcement.
+
+ 7. 🔧 [Troubleshooting](https://constructive.io/learn/troubleshooting)
+Common issues and solutions for pgpm, PostgreSQL, and testing.
+
+## Related Constructive Tooling
+
+### 📦 Package Management
+
+* [pgpm](https://github.com/constructive-io/constructive/tree/main/pgpm/pgpm): **🖥️ PostgreSQL Package Manager** for modular Postgres development. Works with database workspaces, scaffolding, migrations, seeding, and installing database packages.
+
+### 🧪 Testing
+
+* [pgsql-test](https://github.com/constructive-io/constructive/tree/main/postgres/pgsql-test): **📊 Isolated testing environments** with per-test transaction rollbacks—ideal for integration tests, complex migrations, and RLS simulation.
+* [pgsql-seed](https://github.com/constructive-io/constructive/tree/main/postgres/pgsql-seed): **🌱 PostgreSQL seeding utilities** for CSV, JSON, SQL data loading, and pgpm deployment.
+* [supabase-test](https://github.com/constructive-io/constructive/tree/main/postgres/supabase-test): **🧪 Supabase-native test harness** preconfigured for the local Supabase stack—per-test rollbacks, JWT/role context helpers, and CI/GitHub Actions ready.
+* [graphile-test](https://github.com/constructive-io/constructive/tree/main/graphile/graphile-test): **🔐 Authentication mocking** for Graphile-focused test helpers and emulating row-level security contexts.
+* [pg-query-context](https://github.com/constructive-io/constructive/tree/main/postgres/pg-query-context): **🔒 Session context injection** to add session-local context (e.g., `SET LOCAL`) into queries—ideal for setting `role`, `jwt.claims`, and other session settings.
+
+### 🧠 Parsing & AST
+
+* [pgsql-parser](https://www.npmjs.com/package/pgsql-parser): **🔄 SQL conversion engine** that interprets and converts PostgreSQL syntax.
+* [libpg-query-node](https://www.npmjs.com/package/libpg-query): **🌉 Node.js bindings** for `libpg_query`, converting SQL into parse trees.
+* [pg-proto-parser](https://www.npmjs.com/package/pg-proto-parser): **📦 Protobuf parser** for parsing PostgreSQL Protocol Buffers definitions to generate TypeScript interfaces, utility functions, and JSON mappings for enums.
+* [@pgsql/enums](https://www.npmjs.com/package/@pgsql/enums): **🏷️ TypeScript enums** for PostgreSQL AST for safe and ergonomic parsing logic.
+* [@pgsql/types](https://www.npmjs.com/package/@pgsql/types): **📝 Type definitions** for PostgreSQL AST nodes in TypeScript.
+* [@pgsql/utils](https://www.npmjs.com/package/@pgsql/utils): **🛠️ AST utilities** for constructing and transforming PostgreSQL syntax trees.
+
+### 📚 Documentation & Skills
+
+* [constructive-skills](https://github.com/constructive-io/constructive-skills): **📖 Platform documentation and AI agent skills** — feature catalog, blueprint reference, SDK guides (i18n, billing, limits, events, uploads, security, entities, search, AI), and deployment guides.
+
+Install skills for AI coding agents:
+
+```bash
+# All platform skills (security, blueprints, codegen, billing, etc.)
+npx skills add constructive-io/constructive-skills
+
+# Individual repo skills (pgpm, testing, CLI, search, etc.)
+npx skills add https://github.com/constructive-io/constructive --skill pgpm
+npx skills add https://github.com/constructive-io/constructive --skill constructive-testing
+```
+
+## Credits
+
+**🛠 Built by the [Constructive](https://constructive.io) team — creators of modular Postgres tooling for secure, composable backends. If you like our work, contribute on [GitHub](https://github.com/constructive-io).**
+
+## Disclaimer
+
+AS DESCRIBED IN THE LICENSES, THE SOFTWARE IS PROVIDED "AS IS", AT YOUR OWN RISK, AND WITHOUT WARRANTIES OF ANY KIND.
+
+No developer or entity involved in creating this software will be liable for any claims or damages whatsoever associated with your use, inability to use, or your interaction with other users of the code, including any direct, indirect, incidental, special, exemplary, punitive or consequential damages, or loss of profits, cryptocurrencies, tokens, or anything else of value.

package/esm/index.js

@@ -0,0 +1,183 @@
+import { ANTHROPIC_MODELS, AnthropicAdapter } from '@agentic-kit/anthropic';
+import { OLLAMA_MODELS, OllamaAdapter, OllamaClient } from '@agentic-kit/ollama';
+import { OPENAI_COMPATIBLE_MODELS, OpenAIAdapter, } from '@agentic-kit/openai';
+import { createAssistantMessageEventStream, createEmptyUsage, EventStream, getMessageText, normalizeContext, } from '@agentic-kit/protocol';
+import { clearModels, getModel, getModels, getProviders as getModelProviders, registerModel, registerModels, } from './model-registry.js';
+import { clearProviders, getProvider as getRegisteredProvider, getProviders as getRegisteredProviders, registerProvider, unregisterProviders, } from './provider-registry.js';
+import { transformMessages } from './transform-messages.js';
+export * from './transform-messages.js';
+export * from '@agentic-kit/protocol';
+export { createAssistantMessageEventStream, EventStream, OllamaClient };
+export { AnthropicAdapter, OllamaAdapter, OpenAIAdapter };
+registerModels([...OPENAI_COMPATIBLE_MODELS, ...ANTHROPIC_MODELS, ...OLLAMA_MODELS]);
+registerProvider(new OpenAIAdapter());
+registerProvider(new AnthropicAdapter({ apiKey: '' }));
+registerProvider(new OllamaAdapter());
+export function stream(model, context, options) {
+    const provider = getRegisteredProvider(model.api);
+    if (!provider) {
+        throw new Error(`No provider registered for api '${model.api}'`);
+    }
+    return streamWithProvider(provider, model, context, options);
+}
+export async function complete(model, context, options) {
+    const response = stream(model, context, options);
+    return response.result();
+}
+export async function completeText(model, context, options) {
+    const message = await complete(model, context, options);
+    return getMessageText(message);
+}
+export class AgentKit {
+    providers = new Map();
+    current;
+    addProvider(provider) {
+        this.providers.set(getProviderName(provider), provider);
+        if (!this.current) {
+            this.current = provider;
+        }
+        return this;
+    }
+    setProvider(name) {
+        const provider = this.providers.get(name);
+        if (!provider) {
+            throw new Error(`Provider '${name}' not found`);
+        }
+        this.current = provider;
+        return this;
+    }
+    getCurrentProvider() {
+        return this.current;
+    }
+    listProviders() {
+        return Array.from(this.providers.keys());
+    }
+    async generate(input, options) {
+        if (!this.current) {
+            throw new Error('No provider set. Call addProvider() first.');
+        }
+        const provider = this.current;
+        const model = createLegacyModel(provider, input.model, input.maxTokens);
+        const context = legacyInputToContext(input);
+        const streamOptions = {
+            maxTokens: input.maxTokens,
+            temperature: input.temperature,
+        };
+        if (options?.onChunk || input.stream) {
+            options?.onStateChange?.('streaming');
+            try {
+                const response = streamWithProvider(provider, model, context, streamOptions);
+                for await (const event of response) {
+                    if (event.type === 'text_delta') {
+                        options?.onChunk?.(event.delta);
+                    }
+                }
+                assertLegacyGenerateSucceeded(await response.result());
+                options?.onComplete?.();
+            }
+            catch (error) {
+                options?.onError?.(error);
+                throw error;
+            }
+            return;
+        }
+        try {
+            const message = assertLegacyGenerateSucceeded(await completeWithProvider(provider, model, context, streamOptions));
+            options?.onStateChange?.('complete');
+            const text = getMessageText(message);
+            options?.onComplete?.();
+            return text;
+        }
+        catch (error) {
+            options?.onError?.(error);
+            throw error;
+        }
+    }
+    async listModels() {
+        if (!this.current?.listModels) {
+            return [];
+        }
+        const models = await this.current.listModels();
+        return models.map((model) => (typeof model === 'string' ? model : model.id));
+    }
+}
+export function createOllamaKit(baseUrl) {
+    return new AgentKit().addProvider(new OllamaAdapter(baseUrl));
+}
+export function createAnthropicKit(options) {
+    return new AgentKit().addProvider(new AnthropicAdapter(options));
+}
+export function createOpenAIKit(options) {
+    return new AgentKit().addProvider(new OpenAIAdapter(options));
+}
+export function createMultiProviderKit() {
+    return new AgentKit();
+}
+export { clearModels, clearProviders, getModel, getModelProviders, getModels, getRegisteredProvider as getProvider, getRegisteredProviders, registerModel, registerModels, registerProvider, unregisterProviders, };
+function legacyInputToContext(input) {
+    const messages = input.messages
+        ? input.messages
+            .filter((message) => message.role !== 'system')
+            .map((message) => message.role === 'assistant'
+            ? {
+                role: 'assistant',
+                api: 'legacy',
+                provider: 'legacy',
+                model: input.model,
+                content: [{ type: 'text', text: message.content }],
+                usage: createEmptyUsage(),
+                stopReason: 'stop',
+                timestamp: Date.now(),
+            }
+            : {
+                role: 'user',
+                content: message.content,
+                timestamp: Date.now(),
+            })
+        : [{ role: 'user', content: input.prompt ?? '', timestamp: Date.now() }];
+    const systemPrompt = input.system ?? input.messages?.find((message) => message.role === 'system')?.content;
+    return {
+        systemPrompt,
+        messages,
+    };
+}
+function createLegacyModel(provider, modelId, maxTokens) {
+    if (provider.createModel) {
+        return provider.createModel(modelId, {
+            maxOutputTokens: maxTokens,
+        });
+    }
+    return {
+        id: modelId,
+        name: modelId,
+        api: provider.api,
+        provider: getProviderName(provider),
+        baseUrl: '',
+        input: ['text'],
+        reasoning: false,
+        tools: true,
+        maxOutputTokens: maxTokens,
+    };
+}
+function streamWithProvider(provider, model, context, options) {
+    const normalized = normalizeContext(context);
+    const transformedContext = {
+        ...normalized,
+        messages: transformMessages(normalized.messages, model),
+    };
+    return provider.stream(model, transformedContext, options);
+}
+async function completeWithProvider(provider, model, context, options) {
+    const response = streamWithProvider(provider, model, context, options);
+    return response.result();
+}
+function getProviderName(provider) {
+    return provider.name ?? provider.provider;
+}
+function assertLegacyGenerateSucceeded(message) {
+    if (message.stopReason === 'error' || message.stopReason === 'aborted') {
+        throw new Error(message.errorMessage ??
+            (message.stopReason === 'aborted' ? 'Generation aborted.' : 'Generation failed.'), { cause: message });
+    }
+    return message;
+}

package/esm/model-registry.js

@@ -0,0 +1,26 @@
+const modelsByProvider = new Map();
+export function registerModel(model) {
+    const providerModels = modelsByProvider.get(model.provider) ?? new Map();
+    providerModels.set(model.id, model);
+    modelsByProvider.set(model.provider, providerModels);
+}
+export function registerModels(models) {
+    for (const model of models) {
+        registerModel(model);
+    }
+}
+export function getModel(provider, modelId) {
+    return modelsByProvider.get(provider)?.get(modelId);
+}
+export function getModels(provider) {
+    if (provider) {
+        return Array.from(modelsByProvider.get(provider)?.values() ?? []);
+    }
+    return Array.from(modelsByProvider.values()).flatMap((entries) => Array.from(entries.values()));
+}
+export function getProviders() {
+    return Array.from(modelsByProvider.keys());
+}
+export function clearModels() {
+    modelsByProvider.clear();
+}

package/esm/provider-registry.js

@@ -0,0 +1,20 @@
+const providersByApi = new Map();
+export function registerProvider(adapter, sourceId) {
+    providersByApi.set(adapter.api, { adapter, sourceId });
+}
+export function getProvider(api) {
+    return providersByApi.get(api)?.adapter;
+}
+export function getProviders() {
+    return Array.from(providersByApi.values(), (entry) => entry.adapter);
+}
+export function unregisterProviders(sourceId) {
+    for (const [api, entry] of providersByApi.entries()) {
+        if (entry.sourceId === sourceId) {
+            providersByApi.delete(api);
+        }
+    }
+}
+export function clearProviders() {
+    providersByApi.clear();
+}

package/esm/transform-messages.js

@@ -0,0 +1,139 @@
+export 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/index.d.ts

@@ -0,0 +1,34 @@
+import { AnthropicAdapter, type AnthropicOptions } from '@agentic-kit/anthropic';
+import { OllamaAdapter, OllamaClient } from '@agentic-kit/ollama';
+import { OpenAIAdapter, type OpenAIOptions } from '@agentic-kit/openai';
+import { type AssistantMessage, type AssistantMessageEventStream, type Context, createAssistantMessageEventStream, EventStream, type LegacyChatMessage, type LegacyGenerateInput, type LegacyStreamingOptions, type ModelDescriptor, type ProviderAdapter, type StreamOptions } from '@agentic-kit/protocol';
+import { clearModels, getModel, getModels, getProviders as getModelProviders, registerModel, registerModels } from './model-registry.js';
+import { clearProviders, getProvider as getRegisteredProvider, getProviders as getRegisteredProviders, registerProvider, unregisterProviders } from './provider-registry.js';
+export * from './transform-messages.js';
+export * from '@agentic-kit/protocol';
+export { createAssistantMessageEventStream, EventStream, OllamaClient };
+export { AnthropicAdapter, OllamaAdapter, OpenAIAdapter };
+export type { AnthropicOptions, OpenAIOptions };
+export type ChatMessage = LegacyChatMessage;
+export type GenerateInput = LegacyGenerateInput;
+type NamedProviderAdapter = ProviderAdapter & {
+    name?: string;
+};
+export declare function stream(model: ModelDescriptor, context: Context, options?: StreamOptions): AssistantMessageEventStream;
+export declare function complete(model: ModelDescriptor, context: Context, options?: StreamOptions): Promise<AssistantMessage>;
+export declare function completeText(model: ModelDescriptor, context: Context, options?: StreamOptions): Promise<string>;
+export declare class AgentKit {
+    private readonly providers;
+    private current?;
+    addProvider(provider: NamedProviderAdapter): this;
+    setProvider(name: string): this;
+    getCurrentProvider(): NamedProviderAdapter | undefined;
+    listProviders(): string[];
+    generate(input: LegacyGenerateInput, options?: LegacyStreamingOptions): Promise<string | void>;
+    listModels(): Promise<string[]>;
+}
+export declare function createOllamaKit(baseUrl?: string): AgentKit;
+export declare function createAnthropicKit(options: AnthropicOptions | string): AgentKit;
+export declare function createOpenAIKit(options?: OpenAIOptions | string): AgentKit;
+export declare function createMultiProviderKit(): AgentKit;
+export { clearModels, clearProviders, getModel, getModelProviders, getModels, getRegisteredProvider as getProvider, getRegisteredProviders, registerModel, registerModels, registerProvider, unregisterProviders, };

package/index.js

@@ -0,0 +1,222 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterProviders = exports.registerProvider = exports.registerModels = exports.registerModel = exports.getRegisteredProviders = exports.getProvider = exports.getModels = exports.getModelProviders = exports.getModel = exports.clearProviders = exports.clearModels = exports.AgentKit = exports.OpenAIAdapter = exports.OllamaAdapter = exports.AnthropicAdapter = exports.OllamaClient = exports.EventStream = exports.createAssistantMessageEventStream = void 0;
+exports.stream = stream;
+exports.complete = complete;
+exports.completeText = completeText;
+exports.createOllamaKit = createOllamaKit;
+exports.createAnthropicKit = createAnthropicKit;
+exports.createOpenAIKit = createOpenAIKit;
+exports.createMultiProviderKit = createMultiProviderKit;
+const anthropic_1 = require("@agentic-kit/anthropic");
+Object.defineProperty(exports, "AnthropicAdapter", { enumerable: true, get: function () { return anthropic_1.AnthropicAdapter; } });
+const ollama_1 = require("@agentic-kit/ollama");
+Object.defineProperty(exports, "OllamaAdapter", { enumerable: true, get: function () { return ollama_1.OllamaAdapter; } });
+Object.defineProperty(exports, "OllamaClient", { enumerable: true, get: function () { return ollama_1.OllamaClient; } });
+const openai_1 = require("@agentic-kit/openai");
+Object.defineProperty(exports, "OpenAIAdapter", { enumerable: true, get: function () { return openai_1.OpenAIAdapter; } });
+const protocol_1 = require("@agentic-kit/protocol");
+Object.defineProperty(exports, "createAssistantMessageEventStream", { enumerable: true, get: function () { return protocol_1.createAssistantMessageEventStream; } });
+Object.defineProperty(exports, "EventStream", { enumerable: true, get: function () { return protocol_1.EventStream; } });
+const model_registry_js_1 = require("./model-registry.js");
+Object.defineProperty(exports, "clearModels", { enumerable: true, get: function () { return model_registry_js_1.clearModels; } });
+Object.defineProperty(exports, "getModel", { enumerable: true, get: function () { return model_registry_js_1.getModel; } });
+Object.defineProperty(exports, "getModels", { enumerable: true, get: function () { return model_registry_js_1.getModels; } });
+Object.defineProperty(exports, "getModelProviders", { enumerable: true, get: function () { return model_registry_js_1.getProviders; } });
+Object.defineProperty(exports, "registerModel", { enumerable: true, get: function () { return model_registry_js_1.registerModel; } });
+Object.defineProperty(exports, "registerModels", { enumerable: true, get: function () { return model_registry_js_1.registerModels; } });
+const provider_registry_js_1 = require("./provider-registry.js");
+Object.defineProperty(exports, "clearProviders", { enumerable: true, get: function () { return provider_registry_js_1.clearProviders; } });
+Object.defineProperty(exports, "getProvider", { enumerable: true, get: function () { return provider_registry_js_1.getProvider; } });
+Object.defineProperty(exports, "getRegisteredProviders", { enumerable: true, get: function () { return provider_registry_js_1.getProviders; } });
+Object.defineProperty(exports, "registerProvider", { enumerable: true, get: function () { return provider_registry_js_1.registerProvider; } });
+Object.defineProperty(exports, "unregisterProviders", { enumerable: true, get: function () { return provider_registry_js_1.unregisterProviders; } });
+const transform_messages_js_1 = require("./transform-messages.js");
+__exportStar(require("./transform-messages.js"), exports);
+__exportStar(require("@agentic-kit/protocol"), exports);
+(0, model_registry_js_1.registerModels)([...openai_1.OPENAI_COMPATIBLE_MODELS, ...anthropic_1.ANTHROPIC_MODELS, ...ollama_1.OLLAMA_MODELS]);
+(0, provider_registry_js_1.registerProvider)(new openai_1.OpenAIAdapter());
+(0, provider_registry_js_1.registerProvider)(new anthropic_1.AnthropicAdapter({ apiKey: '' }));
+(0, provider_registry_js_1.registerProvider)(new ollama_1.OllamaAdapter());
+function stream(model, context, options) {
+    const provider = (0, provider_registry_js_1.getProvider)(model.api);
+    if (!provider) {
+        throw new Error(`No provider registered for api '${model.api}'`);
+    }
+    return streamWithProvider(provider, model, context, options);
+}
+async function complete(model, context, options) {
+    const response = stream(model, context, options);
+    return response.result();
+}
+async function completeText(model, context, options) {
+    const message = await complete(model, context, options);
+    return (0, protocol_1.getMessageText)(message);
+}
+class AgentKit {
+    providers = new Map();
+    current;
+    addProvider(provider) {
+        this.providers.set(getProviderName(provider), provider);
+        if (!this.current) {
+            this.current = provider;
+        }
+        return this;
+    }
+    setProvider(name) {
+        const provider = this.providers.get(name);
+        if (!provider) {
+            throw new Error(`Provider '${name}' not found`);
+        }
+        this.current = provider;
+        return this;
+    }
+    getCurrentProvider() {
+        return this.current;
+    }
+    listProviders() {
+        return Array.from(this.providers.keys());
+    }
+    async generate(input, options) {
+        if (!this.current) {
+            throw new Error('No provider set. Call addProvider() first.');
+        }
+        const provider = this.current;
+        const model = createLegacyModel(provider, input.model, input.maxTokens);
+        const context = legacyInputToContext(input);
+        const streamOptions = {
+            maxTokens: input.maxTokens,
+            temperature: input.temperature,
+        };
+        if (options?.onChunk || input.stream) {
+            options?.onStateChange?.('streaming');
+            try {
+                const response = streamWithProvider(provider, model, context, streamOptions);
+                for await (const event of response) {
+                    if (event.type === 'text_delta') {
+                        options?.onChunk?.(event.delta);
+                    }
+                }
+                assertLegacyGenerateSucceeded(await response.result());
+                options?.onComplete?.();
+            }
+            catch (error) {
+                options?.onError?.(error);
+                throw error;
+            }
+            return;
+        }
+        try {
+            const message = assertLegacyGenerateSucceeded(await completeWithProvider(provider, model, context, streamOptions));
+            options?.onStateChange?.('complete');
+            const text = (0, protocol_1.getMessageText)(message);
+            options?.onComplete?.();
+            return text;
+        }
+        catch (error) {
+            options?.onError?.(error);
+            throw error;
+        }
+    }
+    async listModels() {
+        if (!this.current?.listModels) {
+            return [];
+        }
+        const models = await this.current.listModels();
+        return models.map((model) => (typeof model === 'string' ? model : model.id));
+    }
+}
+exports.AgentKit = AgentKit;
+function createOllamaKit(baseUrl) {
+    return new AgentKit().addProvider(new ollama_1.OllamaAdapter(baseUrl));
+}
+function createAnthropicKit(options) {
+    return new AgentKit().addProvider(new anthropic_1.AnthropicAdapter(options));
+}
+function createOpenAIKit(options) {
+    return new AgentKit().addProvider(new openai_1.OpenAIAdapter(options));
+}
+function createMultiProviderKit() {
+    return new AgentKit();
+}
+function legacyInputToContext(input) {
+    const messages = input.messages
+        ? input.messages
+            .filter((message) => message.role !== 'system')
+            .map((message) => message.role === 'assistant'
+            ? {
+                role: 'assistant',
+                api: 'legacy',
+                provider: 'legacy',
+                model: input.model,
+                content: [{ type: 'text', text: message.content }],
+                usage: (0, protocol_1.createEmptyUsage)(),
+                stopReason: 'stop',
+                timestamp: Date.now(),
+            }
+            : {
+                role: 'user',
+                content: message.content,
+                timestamp: Date.now(),
+            })
+        : [{ role: 'user', content: input.prompt ?? '', timestamp: Date.now() }];
+    const systemPrompt = input.system ?? input.messages?.find((message) => message.role === 'system')?.content;
+    return {
+        systemPrompt,
+        messages,
+    };
+}
+function createLegacyModel(provider, modelId, maxTokens) {
+    if (provider.createModel) {
+        return provider.createModel(modelId, {
+            maxOutputTokens: maxTokens,
+        });
+    }
+    return {
+        id: modelId,
+        name: modelId,
+        api: provider.api,
+        provider: getProviderName(provider),
+        baseUrl: '',
+        input: ['text'],
+        reasoning: false,
+        tools: true,
+        maxOutputTokens: maxTokens,
+    };
+}
+function streamWithProvider(provider, model, context, options) {
+    const normalized = (0, protocol_1.normalizeContext)(context);
+    const transformedContext = {
+        ...normalized,
+        messages: (0, transform_messages_js_1.transformMessages)(normalized.messages, model),
+    };
+    return provider.stream(model, transformedContext, options);
+}
+async function completeWithProvider(provider, model, context, options) {
+    const response = streamWithProvider(provider, model, context, options);
+    return response.result();
+}
+function getProviderName(provider) {
+    return provider.name ?? provider.provider;
+}
+function assertLegacyGenerateSucceeded(message) {
+    if (message.stopReason === 'error' || message.stopReason === 'aborted') {
+        throw new Error(message.errorMessage ??
+            (message.stopReason === 'aborted' ? 'Generation aborted.' : 'Generation failed.'), { cause: message });
+    }
+    return message;
+}

package/model-registry.d.ts

@@ -0,0 +1,7 @@
+import type { ModelDescriptor } from '@agentic-kit/protocol';
+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

@@ -0,0 +1,39 @@
+{
+  "name": "@agentic-kit/chat",
+  "version": "1.11.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",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@agentic-kit/anthropic": "1.9.1",
+    "@agentic-kit/ollama": "2.7.1",
+    "@agentic-kit/openai": "1.9.1",
+    "@agentic-kit/protocol": "1.9.0"
+  },
+  "keywords": [],
+  "gitHead": "31f7cd3d3cc28cf069056eae5b2a0d4198d154a1"
+}

package/provider-registry.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderAdapter } from '@agentic-kit/protocol';
+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 '@agentic-kit/protocol';
+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');
+}