From b46bcb3f3246bb7bf5b9db5a60dcf1099c0a5777 Mon Sep 17 00:00:00 2001
From: yyyyaaa <phatghaa@gmail.com>
Date: Thu, 7 May 2026 10:20:54 +0700
Subject: [PATCH] refactor(core): share protocol primitives

---
 .../src/components/chat/settings-popover.tsx  |  10 +-
 packages/agent/package.json                   |   1 +
 packages/agent/src/agent-loop.ts              | 210 ++++++++++
 packages/agent/src/agent.ts                   | 192 ++-------
 packages/agent/src/index.ts                   |   1 +
 packages/agent/src/types.ts                   |   2 +-
 packages/agent/src/validation.ts              |   2 +-
 packages/agentic-kit/package.json             |   1 +
 packages/agentic-kit/src/builtins.ts          |  19 +
 packages/agentic-kit/src/event-stream.ts      | 106 +----
 packages/agentic-kit/src/index.ts             |  12 +-
 packages/agentic-kit/src/messages.ts          | 116 +-----
 .../agentic-kit/src/transform-messages.ts     | 194 +--------
 packages/agentic-kit/src/types.ts             | 216 +---------
 packages/anthropic/package.json               |   1 +
 packages/anthropic/src/index.ts               | 366 +----------------
 packages/core/__tests__/core.test.ts          | 135 ++++++
 packages/core/__tests__/tsconfig.json         |  10 +
 packages/core/jest.config.js                  |  22 +
 packages/core/package.json                    |  32 ++
 packages/core/src/event-stream.ts             | 105 +++++
 packages/core/src/index.ts                    |   5 +
 packages/core/src/json.ts                     |  90 ++++
 packages/core/src/messages.ts                 | 116 ++++++
 packages/core/src/transform-messages.ts       | 193 +++++++++
 packages/core/src/types.ts                    | 215 ++++++++++
 packages/core/tsconfig.esm.json               |   9 +
 packages/core/tsconfig.json                   |   9 +
 packages/ollama/package.json                  |   1 +
 packages/ollama/src/index.ts                  | 254 +-----------
 packages/openai/package.json                  |   1 +
 packages/openai/src/index.ts                  | 384 +-----------------
 pnpm-lock.yaml                                |  18 +
 scripts/typecheck.js                          |  14 +
 34 files changed, 1319 insertions(+), 1743 deletions(-)
 create mode 100644 packages/agent/src/agent-loop.ts
 create mode 100644 packages/agentic-kit/src/builtins.ts
 create mode 100644 packages/core/__tests__/core.test.ts
 create mode 100644 packages/core/__tests__/tsconfig.json
 create mode 100644 packages/core/jest.config.js
 create mode 100644 packages/core/package.json
 create mode 100644 packages/core/src/event-stream.ts
 create mode 100644 packages/core/src/index.ts
 create mode 100644 packages/core/src/json.ts
 create mode 100644 packages/core/src/messages.ts
 create mode 100644 packages/core/src/transform-messages.ts
 create mode 100644 packages/core/src/types.ts
 create mode 100644 packages/core/tsconfig.esm.json
 create mode 100644 packages/core/tsconfig.json

diff --git a/apps/tanstack-chat-demo/src/components/chat/settings-popover.tsx b/apps/tanstack-chat-demo/src/components/chat/settings-popover.tsx
index 339c04a..a8c0914 100644
--- a/apps/tanstack-chat-demo/src/components/chat/settings-popover.tsx
+++ b/apps/tanstack-chat-demo/src/components/chat/settings-popover.tsx
@@ -29,9 +29,9 @@ export function SettingsPopover({ settings, onChange, onRefresh }: Props) {
       <PopoverContent
         align="end"
         sideOffset={8}
-        className="w-[360px] rounded-[16px] border-0 bg-bg-elevated p-0 shadow-[0_20px_60px_-15px_rgba(0,0,0,0.25),0_0_0_0.5px_rgba(0,0,0,0.08)]"
+        className="max-h-[var(--radix-popover-content-available-height)] w-[360px] overflow-hidden rounded-[16px] border-0 bg-bg-elevated p-0 shadow-[0_20px_60px_-15px_rgba(0,0,0,0.25),0_0_0_0.5px_rgba(0,0,0,0.08)]"
       >
-        <div className="px-4 pt-4 pb-3">
+        <div className="shrink-0 px-4 pt-4 pb-3">
           <h3 className="text-[17px] font-semibold text-label" style={{ letterSpacing: '-0.43px' }}>
             Settings
           </h3>
@@ -40,7 +40,7 @@ export function SettingsPopover({ settings, onChange, onRefresh }: Props) {
           </p>
         </div>
 
-        <div className="px-4">
+        <div className="min-h-0 overflow-y-auto px-4">
           <div className="overflow-hidden rounded-[12px] bg-bg-2">
             <Field label="OpenAI key">
               <Input
@@ -79,13 +79,13 @@ export function SettingsPopover({ settings, onChange, onRefresh }: Props) {
               value={settings.systemPrompt}
               onChange={(e) => onChange({ systemPrompt: e.target.value })}
               placeholder="Optional instructions for the assistant"
-              className="mt-1.5 resize-none rounded-[8px] border-0 bg-bg px-2.5 py-2 text-[14px] leading-[1.4] text-label shadow-none placeholder:text-label-3 focus-visible:ring-0"
+              className="mt-1.5 max-h-[min(40dvh,320px)] resize-y overflow-y-auto rounded-[8px] border-0 bg-bg px-2.5 py-2 text-[14px] leading-[1.4] text-label shadow-none ![field-sizing:fixed] placeholder:text-label-3 focus-visible:ring-0"
               style={{ letterSpacing: '-0.15px' }}
             />
           </div>
         </div>
 
-        <div className="mt-4 flex items-center justify-between border-t border-hairline px-4 py-3">
+        <div className="mt-4 flex shrink-0 items-center justify-between border-t border-hairline px-4 py-3">
           <span className="text-[12.5px] text-label-2">Cached in this browser</span>
           <button
             type="button"
diff --git a/packages/agent/package.json b/packages/agent/package.json
index c4cbeb2..78d385c 100644
--- a/packages/agent/package.json
+++ b/packages/agent/package.json
@@ -29,6 +29,7 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
+    "@agentic-kit/core": "workspace:*",
     "agentic-kit": "workspace:*"
   },
   "keywords": []
diff --git a/packages/agent/src/agent-loop.ts b/packages/agent/src/agent-loop.ts
new file mode 100644
index 0000000..fe77215
--- /dev/null
+++ b/packages/agent/src/agent-loop.ts
@@ -0,0 +1,210 @@
+import {
+  type AssistantMessage,
+  type Context,
+  createToolResultMessage,
+  type Message,
+  type StreamOptions,
+} from '@agentic-kit/core';
+import { stream as defaultStream } from 'agentic-kit';
+
+import type {
+  AgentEvent,
+  AgentOptions,
+  AgentState,
+  AgentTool,
+  AgentToolResult,
+} from './types.js';
+import { validateToolArguments as defaultValidateToolArguments } from './validation.js';
+
+export type AgentEventSink = (event: AgentEvent) => void | Promise<void>;
+
+export type AgentLoopConfig = {
+  initialMessages?: Message[];
+  state: AgentState;
+  streamFn?: AgentOptions['streamFn'];
+  transformContext?: AgentOptions['transformContext'];
+  validateToolArguments?: AgentOptions['validateToolArguments'];
+  signal: AbortSignal;
+};
+
+export async function runAgentLoop(config: AgentLoopConfig, emit: AgentEventSink): Promise<Message[]> {
+  const messages = [...config.state.messages];
+
+  await emit({ type: 'agent_start' });
+
+  if (config.initialMessages && config.initialMessages.length > 0) {
+    for (const message of config.initialMessages) {
+      await emit({ type: 'message_start', message });
+      messages.push(message);
+      await emit({ type: 'message_end', message });
+    }
+  }
+
+  while (true) {
+    await emit({ type: 'turn_start' });
+
+    const assistantMessage = await generateAssistantMessage(config, messages, emit);
+    messages.push(assistantMessage);
+    await emit({ type: 'message_end', message: assistantMessage });
+
+    if (assistantMessage.stopReason === 'error' || assistantMessage.stopReason === 'aborted') {
+      await emit({ type: 'turn_end', message: assistantMessage, toolResults: [] });
+      break;
+    }
+
+    const toolCalls = assistantMessage.content.filter((block) => block.type === 'toolCall');
+    if (toolCalls.length === 0) {
+      await emit({ type: 'turn_end', message: assistantMessage, toolResults: [] });
+      break;
+    }
+
+    const toolResults = await executeToolCalls(config, toolCalls, emit);
+    for (const toolResult of toolResults) {
+      await emit({ type: 'message_start', message: toolResult });
+      messages.push(toolResult);
+      await emit({ type: 'message_end', message: toolResult });
+    }
+
+    await emit({ type: 'turn_end', message: assistantMessage, toolResults });
+  }
+
+  await emit({ type: 'agent_end', messages });
+  return messages;
+}
+
+async function generateAssistantMessage(
+  config: AgentLoopConfig,
+  messages: Message[],
+  emit: AgentEventSink
+): Promise<AssistantMessage> {
+  const transformedMessages = config.transformContext
+    ? await config.transformContext(messages, config.signal)
+    : messages;
+
+  const context: Context = {
+    systemPrompt: config.state.systemPrompt,
+    tools: config.state.tools,
+    messages: transformedMessages,
+  };
+
+  const streamFn = config.streamFn ?? defaultStream;
+  const streamResult = streamFn(config.state.model, context, {
+    ...(config.state.streamOptions ?? {}),
+    signal: config.signal,
+  } as StreamOptions);
+
+  for await (const event of streamResult) {
+    switch (event.type) {
+    case 'start':
+      await emit({ type: 'message_start', message: event.partial });
+      break;
+    case 'text_start':
+    case 'text_delta':
+    case 'text_end':
+    case 'thinking_start':
+    case 'thinking_delta':
+    case 'thinking_end':
+    case 'toolcall_start':
+    case 'toolcall_delta':
+    case 'toolcall_end':
+      await emit({
+        type: 'message_update',
+        message: event.partial,
+        assistantMessageEvent: event,
+      });
+      break;
+    case 'done':
+    case 'error':
+      break;
+    }
+  }
+
+  return streamResult.result();
+}
+
+async function executeToolCalls(
+  config: AgentLoopConfig,
+  toolCalls: Array<Extract<AssistantMessage['content'][number], { type: 'toolCall' }>>,
+  emit: AgentEventSink
+) {
+  const results = [];
+
+  for (const toolCall of toolCalls) {
+    const tool = config.state.tools.find((candidate) => candidate.name === toolCall.name);
+    await emit({
+      type: 'tool_execution_start',
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      args: toolCall.arguments as Record<string, unknown>,
+    });
+
+    let result: AgentToolResult;
+    let isError = false;
+
+    try {
+      if (!tool) {
+        throw new Error(`Tool '${toolCall.name}' not found`);
+      }
+
+      const validateToolArguments = config.validateToolArguments ?? defaultValidateToolArguments;
+      const validatedArgs = validateToolArguments(
+        tool.parameters,
+        toolCall.arguments as Record<string, unknown>
+      );
+
+      result = await executeTool(tool, toolCall.id, validatedArgs, config.signal, emit);
+    } catch (error) {
+      result = {
+        content: [
+          {
+            type: 'text',
+            text: error instanceof Error ? error.message : String(error),
+          },
+        ],
+      };
+      isError = true;
+    }
+
+    await emit({
+      type: 'tool_execution_end',
+      toolCallId: toolCall.id,
+      toolName: toolCall.name,
+      result,
+      isError,
+    });
+
+    results.push(
+      createToolResultMessage(toolCall.id, toolCall.name, result.content, isError)
+    );
+  }
+
+  return results;
+}
+
+async function executeTool(
+  tool: AgentTool,
+  toolCallId: string,
+  args: Record<string, unknown>,
+  signal: AbortSignal,
+  emit: AgentEventSink
+): Promise<AgentToolResult> {
+  const updateEvents: Promise<void>[] = [];
+
+  try {
+    return await tool.execute(toolCallId, args, signal, (partialResult) => {
+      updateEvents.push(
+        Promise.resolve(
+          emit({
+            type: 'tool_execution_update',
+            toolCallId,
+            toolName: tool.name,
+            args,
+            partialResult,
+          })
+        )
+      );
+    });
+  } finally {
+    await Promise.all(updateEvents);
+  }
+}
diff --git a/packages/agent/src/agent.ts b/packages/agent/src/agent.ts
index 8fc8503..5ddd3bc 100644
--- a/packages/agent/src/agent.ts
+++ b/packages/agent/src/agent.ts
@@ -1,19 +1,16 @@
 import {
-  type AssistantMessage,
-  type Context,
-  createToolResultMessage,
   createUserMessage,
   type Message,
-  stream,
   type StreamOptions,
-} from 'agentic-kit';
+} from '@agentic-kit/core';
+import { stream } from 'agentic-kit';
 
+import { runAgentLoop } from './agent-loop.js';
 import type {
   AgentEvent,
   AgentOptions,
   AgentState,
   AgentTool,
-  AgentToolResult,
 } from './types.js';
 import { validateToolArguments as defaultValidateToolArguments } from './validation.js';
 
@@ -128,46 +125,21 @@ export class Agent {
       this._state.error = undefined;
 
       try {
-        this.emit({ type: 'agent_start' });
-
-        if (initialMessages && initialMessages.length > 0) {
-          for (const message of initialMessages) {
-            this.emit({ type: 'message_start', message });
-            this.appendMessage(message);
-            this.emit({ type: 'message_end', message });
-          }
-        }
-
-        while (true) {
-          this.emit({ type: 'turn_start' });
-
-          const assistantMessage = await this.generateAssistantMessage(this.abortController.signal);
-          this.appendMessage(assistantMessage);
-          this.emit({ type: 'message_end', message: assistantMessage });
-
-          if (assistantMessage.stopReason === 'error' || assistantMessage.stopReason === 'aborted') {
-            this._state.error = assistantMessage.errorMessage;
-            this.emit({ type: 'turn_end', message: assistantMessage, toolResults: [] });
-            break;
-          }
-
-          const toolCalls = assistantMessage.content.filter((block) => block.type === 'toolCall');
-          if (toolCalls.length === 0) {
-            this.emit({ type: 'turn_end', message: assistantMessage, toolResults: [] });
-            break;
-          }
-
-          const toolResults = await this.executeToolCalls(toolCalls, this.abortController.signal);
-          for (const toolResult of toolResults) {
-            this.emit({ type: 'message_start', message: toolResult });
-            this.appendMessage(toolResult);
-            this.emit({ type: 'message_end', message: toolResult });
-          }
-
-          this.emit({ type: 'turn_end', message: assistantMessage, toolResults });
-        }
-
-        this.emit({ type: 'agent_end', messages: [...this._state.messages] });
+        await runAgentLoop(
+          {
+            initialMessages,
+            state: {
+              ...this._state,
+              messages: [...this._state.messages],
+              tools: [...this._state.tools],
+            },
+            streamFn: this.streamFn,
+            transformContext: this.transformContext,
+            validateToolArguments: this.validateToolArguments,
+            signal: this.abortController.signal,
+          },
+          (event) => this.emit(event)
+        );
       } finally {
         this._state.isStreaming = false;
         this._state.streamMessage = null;
@@ -179,120 +151,30 @@ export class Agent {
     await this.running;
   }
 
-  private async generateAssistantMessage(signal: AbortSignal): Promise<AssistantMessage> {
-    const messages = this.transformContext
-      ? await this.transformContext(this._state.messages, signal)
-      : this._state.messages;
-
-    const context: Context = {
-      systemPrompt: this._state.systemPrompt,
-      tools: this._state.tools,
-      messages,
-    };
-
-    const streamResult = this.streamFn(this._state.model, context, {
-      ...(this._state.streamOptions ?? {}),
-      signal,
-    });
-
-    for await (const event of streamResult) {
-      switch (event.type) {
-      case 'start':
-        this._state.streamMessage = event.partial;
-        this.emit({ type: 'message_start', message: event.partial });
-        break;
-      case 'text_start':
-      case 'text_delta':
-      case 'text_end':
-      case 'thinking_start':
-      case 'thinking_delta':
-      case 'thinking_end':
-      case 'toolcall_start':
-      case 'toolcall_delta':
-      case 'toolcall_end':
-        this._state.streamMessage = event.partial;
-        this.emit({
-          type: 'message_update',
-          message: event.partial,
-          assistantMessageEvent: event,
-        });
-        break;
-      case 'done':
-      case 'error':
+  private emit(event: AgentEvent): void {
+    switch (event.type) {
+    case 'message_start':
+    case 'message_update':
+      if (event.message.role === 'assistant') {
+        this._state.streamMessage = event.message;
+      }
+      break;
+    case 'message_end':
+      this._state.messages = [...this._state.messages, event.message];
+      if (event.message.role === 'assistant') {
         this._state.streamMessage = null;
-        break;
       }
-    }
-
-    return streamResult.result();
-  }
-
-  private async executeToolCalls(
-    toolCalls: Array<Extract<AssistantMessage['content'][number], { type: 'toolCall' }>>,
-    signal: AbortSignal
-  ) {
-    const results = [];
-
-    for (const toolCall of toolCalls) {
-      const tool = this._state.tools.find((candidate) => candidate.name === toolCall.name);
-      this.emit({
-        type: 'tool_execution_start',
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        args: toolCall.arguments as Record<string, unknown>,
-      });
-
-      let result: AgentToolResult;
-      let isError = false;
-
-      try {
-        if (!tool) {
-          throw new Error(`Tool '${toolCall.name}' not found`);
-        }
-
-        const validatedArgs = this.validateToolArguments(
-          tool.parameters,
-          toolCall.arguments as Record<string, unknown>
-        );
-
-        result = await tool.execute(toolCall.id, validatedArgs, signal, (partialResult) => {
-          this.emit({
-            type: 'tool_execution_update',
-            toolCallId: toolCall.id,
-            toolName: toolCall.name,
-            args: validatedArgs,
-            partialResult,
-          });
-        });
-      } catch (error) {
-        result = {
-          content: [
-            {
-              type: 'text',
-              text: error instanceof Error ? error.message : String(error),
-            },
-          ],
-        };
-        isError = true;
+      break;
+    case 'turn_end':
+      if (event.message.stopReason === 'error' || event.message.stopReason === 'aborted') {
+        this._state.error = event.message.errorMessage;
       }
-
-      this.emit({
-        type: 'tool_execution_end',
-        toolCallId: toolCall.id,
-        toolName: toolCall.name,
-        result,
-        isError,
-      });
-
-      results.push(
-        createToolResultMessage(toolCall.id, toolCall.name, result.content, isError)
-      );
+      break;
+    case 'agent_end':
+      this._state.streamMessage = null;
+      break;
     }
 
-    return results;
-  }
-
-  private emit(event: AgentEvent): void {
     for (const listener of this.listeners) {
       listener(event);
     }
diff --git a/packages/agent/src/index.ts b/packages/agent/src/index.ts
index b8b99bb..e8cbfda 100644
--- a/packages/agent/src/index.ts
+++ b/packages/agent/src/index.ts
@@ -1,3 +1,4 @@
 export * from './agent.js';
+export * from './agent-loop.js';
 export * from './types.js';
 export * from './validation.js';
diff --git a/packages/agent/src/types.ts b/packages/agent/src/types.ts
index 1486987..ab5e0c0 100644
--- a/packages/agent/src/types.ts
+++ b/packages/agent/src/types.ts
@@ -8,7 +8,7 @@ import type {
   StreamOptions,
   ToolDefinition,
   ToolResultMessage,
-} from 'agentic-kit';
+} from '@agentic-kit/core';
 
 export interface AgentToolResult<TDetails = unknown> {
   content: ToolResultMessage<TDetails>['content'];
diff --git a/packages/agent/src/validation.ts b/packages/agent/src/validation.ts
index 51634c7..9b021d1 100644
--- a/packages/agent/src/validation.ts
+++ b/packages/agent/src/validation.ts
@@ -1,4 +1,4 @@
-import type { JsonSchema } from 'agentic-kit';
+import type { JsonSchema } from '@agentic-kit/core';
 
 export function validateToolArguments(
   schema: JsonSchema,
diff --git a/packages/agentic-kit/package.json b/packages/agentic-kit/package.json
index 4bf8502..8e83fad 100644
--- a/packages/agentic-kit/package.json
+++ b/packages/agentic-kit/package.json
@@ -29,6 +29,7 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
+    "@agentic-kit/core": "workspace:*",
     "@agentic-kit/anthropic": "workspace:*",
     "@agentic-kit/ollama": "workspace:*",
     "@agentic-kit/openai": "workspace:*"
diff --git a/packages/agentic-kit/src/builtins.ts b/packages/agentic-kit/src/builtins.ts
new file mode 100644
index 0000000..8e0efbc
--- /dev/null
+++ b/packages/agentic-kit/src/builtins.ts
@@ -0,0 +1,19 @@
+import { ANTHROPIC_MODELS, AnthropicAdapter } from '@agentic-kit/anthropic';
+import { OLLAMA_MODELS, OllamaAdapter } from '@agentic-kit/ollama';
+import { OPENAI_COMPATIBLE_MODELS, OpenAIAdapter } from '@agentic-kit/openai';
+
+import { clearModels, registerModels } from './model-registry.js';
+import { clearProviders, registerProvider } from './provider-registry.js';
+
+export function registerBuiltInProviders(): void {
+  registerModels([...OPENAI_COMPATIBLE_MODELS, ...ANTHROPIC_MODELS, ...OLLAMA_MODELS]);
+  registerProvider(new OpenAIAdapter());
+  registerProvider(new AnthropicAdapter({ apiKey: '' }));
+  registerProvider(new OllamaAdapter());
+}
+
+export function resetBuiltInProviders(): void {
+  clearModels();
+  clearProviders();
+  registerBuiltInProviders();
+}
diff --git a/packages/agentic-kit/src/event-stream.ts b/packages/agentic-kit/src/event-stream.ts
index fd73bc7..8c5de61 100644
--- a/packages/agentic-kit/src/event-stream.ts
+++ b/packages/agentic-kit/src/event-stream.ts
@@ -1,105 +1 @@
-import type {
-  AssistantMessage,
-  AssistantMessageEvent,
-  AssistantMessageEventStream,
-} from './types.js';
-
-export class EventStream<TEvent, TResult = TEvent> implements AsyncIterable<TEvent> {
-  private readonly queue: TEvent[] = [];
-  private readonly waiting: Array<(result: IteratorResult<TEvent>) => void> = [];
-  private done = false;
-  private readonly finalResultPromise: Promise<TResult>;
-  private resolveFinalResult!: (value: TResult) => void;
-
-  constructor(
-    private readonly isTerminal: (event: TEvent) => boolean,
-    private readonly extractResult: (event: TEvent) => TResult
-  ) {
-    this.finalResultPromise = new Promise<TResult>((resolve) => {
-      this.resolveFinalResult = resolve;
-    });
-  }
-
-  push(event: TEvent): void {
-    if (this.done) {
-      return;
-    }
-
-    if (this.isTerminal(event)) {
-      this.done = true;
-      this.resolveFinalResult(this.extractResult(event));
-    }
-
-    const waiter = this.waiting.shift();
-    if (waiter) {
-      waiter({ value: event, done: false });
-      return;
-    }
-
-    this.queue.push(event);
-  }
-
-  end(result?: TResult): void {
-    this.done = true;
-    if (result !== undefined) {
-      this.resolveFinalResult(result);
-    }
-
-    while (this.waiting.length > 0) {
-      this.waiting.shift()!({ value: undefined as never, done: true });
-    }
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterator<TEvent> {
-    while (true) {
-      if (this.queue.length > 0) {
-        yield this.queue.shift()!;
-        continue;
-      }
-
-      if (this.done) {
-        return;
-      }
-
-      const next = await new Promise<IteratorResult<TEvent>>((resolve) => {
-        this.waiting.push(resolve);
-      });
-
-      if (next.done) {
-        return;
-      }
-
-      yield next.value;
-    }
-  }
-
-  result(): Promise<TResult> {
-    return this.finalResultPromise;
-  }
-}
-
-export class DefaultAssistantMessageEventStream
-  extends EventStream<AssistantMessageEvent, AssistantMessage>
-  implements AssistantMessageEventStream
-{
-  constructor() {
-    super(
-      (event) => event.type === 'done' || event.type === 'error',
-      (event) => {
-        if (event.type === 'done') {
-          return event.message;
-        }
-
-        if (event.type === 'error') {
-          return event.error;
-        }
-
-        throw new Error('Unexpected terminal event');
-      }
-    );
-  }
-}
-
-export function createAssistantMessageEventStream(): DefaultAssistantMessageEventStream {
-  return new DefaultAssistantMessageEventStream();
-}
+export * from '@agentic-kit/core';
diff --git a/packages/agentic-kit/src/index.ts b/packages/agentic-kit/src/index.ts
index f8b0fd2..93e31b8 100644
--- a/packages/agentic-kit/src/index.ts
+++ b/packages/agentic-kit/src/index.ts
@@ -1,11 +1,11 @@
-import { ANTHROPIC_MODELS, AnthropicAdapter, type AnthropicOptions } from '@agentic-kit/anthropic';
-import { OLLAMA_MODELS,OllamaAdapter, OllamaClient } from '@agentic-kit/ollama';
+import { AnthropicAdapter, type AnthropicOptions } from '@agentic-kit/anthropic';
+import { OllamaAdapter, OllamaClient } from '@agentic-kit/ollama';
 import {
-  OPENAI_COMPATIBLE_MODELS,
   OpenAIAdapter,
   type OpenAIOptions,
 } from '@agentic-kit/openai';
 
+import { registerBuiltInProviders, resetBuiltInProviders } from './builtins.js';
 import { createAssistantMessageEventStream, EventStream } from './event-stream.js';
 import { getMessageText, normalizeContext } from './messages.js';
 import {
@@ -41,6 +41,7 @@ export * from './messages.js';
 export * from './transform-messages.js';
 export * from './types.js';
 
+export { registerBuiltInProviders, resetBuiltInProviders };
 export { createAssistantMessageEventStream, EventStream, OllamaClient };
 export { AnthropicAdapter, OllamaAdapter, OpenAIAdapter };
 export type { AnthropicOptions, OpenAIOptions };
@@ -50,10 +51,7 @@ export type GenerateInput = LegacyGenerateInput;
 
 type NamedProviderAdapter = ProviderAdapter & { name?: string };
 
-registerModels([...OPENAI_COMPATIBLE_MODELS, ...ANTHROPIC_MODELS, ...OLLAMA_MODELS]);
-registerProvider(new OpenAIAdapter());
-registerProvider(new AnthropicAdapter({ apiKey: '' }));
-registerProvider(new OllamaAdapter());
+registerBuiltInProviders();
 
 export function stream(
   model: ModelDescriptor,
diff --git a/packages/agentic-kit/src/messages.ts b/packages/agentic-kit/src/messages.ts
index 5a01e72..8c5de61 100644
--- a/packages/agentic-kit/src/messages.ts
+++ b/packages/agentic-kit/src/messages.ts
@@ -1,115 +1 @@
-import type {
-  AssistantMessage,
-  Context,
-  ImageContent,
-  Message,
-  ModelDescriptor,
-  TextContent,
-  ToolCallContent,
-  ToolResultMessage,
-  Usage,
-  UserMessage,
-} from './types.js';
-
-export function createEmptyUsage(): Usage {
-  return {
-    input: 0,
-    output: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    totalTokens: 0,
-    cost: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      total: 0,
-    },
-  };
-}
-
-export function calculateUsageCost(model: ModelDescriptor, usage: Usage): Usage['cost'] {
-  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;
-}
-
-export function createAssistantMessage(model: ModelDescriptor): AssistantMessage {
-  return {
-    role: 'assistant',
-    api: model.api,
-    provider: model.provider,
-    model: model.id,
-    content: [],
-    usage: createEmptyUsage(),
-    stopReason: 'stop',
-    timestamp: Date.now(),
-  };
-}
-
-export function createTextContent(text = ''): TextContent {
-  return { type: 'text', text };
-}
-
-export function createImageContent(data: string, mimeType: string): ImageContent {
-  return { type: 'image', data, mimeType };
-}
-
-export function createToolCall(id: string, name: string): ToolCallContent {
-  return { type: 'toolCall', id, name, arguments: {}, rawArguments: '' };
-}
-
-export function createUserMessage(content: UserMessage['content']): UserMessage {
-  return {
-    role: 'user',
-    content,
-    timestamp: Date.now(),
-  };
-}
-
-export function createToolResultMessage(
-  toolCallId: string,
-  toolName: string,
-  content: ToolResultMessage['content'],
-  isError = false
-): ToolResultMessage {
-  return {
-    role: 'toolResult',
-    toolCallId,
-    toolName,
-    content,
-    isError,
-    timestamp: Date.now(),
-  };
-}
-
-export function getMessageText(message: AssistantMessage): string {
-  return message.content
-    .filter((block): block is TextContent => block.type === 'text')
-    .map((block) => block.text)
-    .join('');
-}
-
-export function cloneMessage<TMessage extends Message>(message: TMessage): TMessage {
-  return JSON.parse(JSON.stringify(message)) as TMessage;
-}
-
-export function normalizeContext(context: Context): Context {
-  return {
-    systemPrompt: context.systemPrompt,
-    tools: context.tools ?? [],
-    messages: context.messages.map((message) => ensureTimestamp(cloneMessage(message))),
-  };
-}
-
-function ensureTimestamp<TMessage extends Message>(message: TMessage): TMessage {
-  if (typeof message.timestamp !== 'number') {
-    (message as Message).timestamp = Date.now();
-  }
-  return message;
-}
+export * from '@agentic-kit/core';
diff --git a/packages/agentic-kit/src/transform-messages.ts b/packages/agentic-kit/src/transform-messages.ts
index 589f325..8c5de61 100644
--- a/packages/agentic-kit/src/transform-messages.ts
+++ b/packages/agentic-kit/src/transform-messages.ts
@@ -1,193 +1 @@
-import type {
-  Message,
-  ModelDescriptor,
-  TextContent,
-  ThinkingContent,
-  ToolCallContent,
-  ToolResultMessage,
-} from './types.js';
-
-export function transformMessages(messages: Message[], model: ModelDescriptor): Message[] {
-  const toolCallIdMap = new Map<string, string>();
-
-  const transformed: Message[] = messages.flatMap((message): 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: Array<TextContent | ThinkingContent | ToolCallContent> = message.content.flatMap(
-      (block): Array<TextContent | ThinkingContent | ToolCallContent> => {
-        if (block.type === 'thinking') {
-          if (sameModel) {
-            return [block];
-          }
-
-          if (!block.thinking.trim()) {
-            return [];
-          }
-
-          const thinkingAsText: TextContent = {
-            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: ToolCallContent =
-            normalizedId === block.id ? block : { ...block, id: normalizedId };
-          return [toolCall];
-        }
-
-        return [block];
-      }
-    );
-
-    return [{ ...message, content }];
-  });
-
-  return insertSyntheticToolResults(transformed);
-}
-
-function insertSyntheticToolResults(messages: Message[]): Message[] {
-  const result: Message[] = [];
-  let pendingToolCalls: ToolCallContent[] = [];
-  let seenToolResults = new Set<string>();
-
-  for (const message of messages) {
-    if (message.role === 'assistant') {
-      flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
-
-      pendingToolCalls = message.content.filter(
-        (block): block is ToolCallContent => block.type === 'toolCall'
-      );
-      seenToolResults = new Set<string>();
-      result.push(message);
-      continue;
-    }
-
-    if (message.role === 'toolResult') {
-      seenToolResults.add(message.toolCallId);
-      result.push(message);
-      continue;
-    }
-
-    flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
-    pendingToolCalls = [];
-    seenToolResults = new Set<string>();
-    result.push(message);
-  }
-
-  flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
-  return result;
-}
-
-function flushPendingToolCalls(
-  result: Message[],
-  pendingToolCalls: ToolCallContent[],
-  seenToolResults: Set<string>
-): void {
-  if (pendingToolCalls.length === 0) {
-    return;
-  }
-
-  for (const toolCall of pendingToolCalls) {
-    if (seenToolResults.has(toolCall.id)) {
-      continue;
-    }
-
-    const synthetic: ToolResultMessage = {
-      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: string, model: ModelDescriptor): string {
-  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: ModelDescriptor): 'passthrough' | 'safe64' | 'mistral9' {
-  if (model.provider === 'anthropic' || model.api === 'anthropic-messages') {
-    return 'safe64';
-  }
-
-  return 'passthrough';
-}
-
-function stableId(input: string, length: number, pattern: RegExp): string {
-  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: string, length: number): string {
-  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');
-}
+export * from '@agentic-kit/core';
diff --git a/packages/agentic-kit/src/types.ts b/packages/agentic-kit/src/types.ts
index 00b432c..8c5de61 100644
--- a/packages/agentic-kit/src/types.ts
+++ b/packages/agentic-kit/src/types.ts
@@ -1,215 +1 @@
-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;
-}
-
-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>;
-}
+export * from '@agentic-kit/core';
diff --git a/packages/anthropic/package.json b/packages/anthropic/package.json
index 0058e80..94794b2 100644
--- a/packages/anthropic/package.json
+++ b/packages/anthropic/package.json
@@ -30,6 +30,7 @@
   },
   "keywords": [],
   "dependencies": {
+    "@agentic-kit/core": "workspace:*",
     "cross-fetch": "^4.1.0"
   }
 }
diff --git a/packages/anthropic/src/index.ts b/packages/anthropic/src/index.ts
index 79efe7c..8624c1b 100644
--- a/packages/anthropic/src/index.ts
+++ b/packages/anthropic/src/index.ts
@@ -1,244 +1,22 @@
+import {
+  type AssistantMessageEventStream,
+  calculateUsageCost,
+  clone,
+  type Context,
+  createAssistantMessage,
+  createToolCall,
+  DefaultAssistantMessageEventStream,
+  type JsonValue,
+  type Message,
+  type ModelDescriptor,
+  parsePartialJson,
+  type StreamOptions,
+  type TextContent,
+  type ThinkingContent,
+  type ToolCallContent,
+} from '@agentic-kit/core';
 import fetch from 'cross-fetch';
 
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
-
-interface JsonObject {
-  [key: string]: JsonValue | undefined;
-}
-
-interface JsonSchema {
-  additionalProperties?: boolean | JsonSchema;
-  description?: string;
-  enum?: JsonValue[];
-  items?: JsonSchema | JsonSchema[];
-  properties?: Record<string, JsonSchema>;
-  required?: string[];
-  type?: string | string[];
-}
-
-interface ModelDescriptor {
-  id: string;
-  name: string;
-  api: string;
-  provider: string;
-  baseUrl: string;
-  input: Array<'text' | 'image'>;
-  reasoning: boolean;
-  tools?: boolean;
-  contextWindow?: number;
-  maxOutputTokens?: number;
-  cost?: {
-    input?: number;
-    output?: number;
-    cacheRead?: number;
-    cacheWrite?: number;
-  };
-  headers?: Record<string, string>;
-}
-
-interface TextContent {
-  type: 'text';
-  text: string;
-}
-
-interface ImageContent {
-  type: 'image';
-  data: string;
-  mimeType: string;
-}
-
-interface ThinkingContent {
-  type: 'thinking';
-  thinking: string;
-}
-
-interface ToolCallContent {
-  type: 'toolCall';
-  id: string;
-  name: string;
-  arguments: Record<string, JsonValue | undefined>;
-  rawArguments?: string;
-}
-
-interface Usage {
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheWrite: number;
-  totalTokens: number;
-  cost: {
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-    total: number;
-  };
-}
-
-type Message =
-  | {
-      role: 'user';
-      content: string | Array<TextContent | ImageContent>;
-      timestamp: number;
-    }
-  | {
-      role: 'assistant';
-      content: Array<TextContent | ThinkingContent | ToolCallContent>;
-      api: string;
-      provider: string;
-      model: string;
-      usage: Usage;
-      stopReason: 'stop' | 'length' | 'toolUse' | 'error' | 'aborted';
-      errorMessage?: string;
-      timestamp: number;
-    }
-  | {
-      role: 'toolResult';
-      toolCallId: string;
-      toolName: string;
-      content: Array<TextContent | ImageContent>;
-      isError: boolean;
-      details?: unknown;
-      timestamp: number;
-    };
-
-interface ToolDefinition {
-  name: string;
-  description: string;
-  parameters: JsonSchema;
-}
-
-interface Context {
-  systemPrompt?: string;
-  messages: Message[];
-  tools?: ToolDefinition[];
-}
-
-interface StreamOptions {
-  apiKey?: string;
-  headers?: Record<string, string>;
-  maxTokens?: number;
-  onPayload?: (payload: unknown) => void;
-  reasoning?: 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
-  signal?: AbortSignal;
-  temperature?: number;
-}
-
-type AssistantMessage = Extract<Message, { role: 'assistant' }>;
-
-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: 'stop' | 'length' | 'toolUse'; message: AssistantMessage }
-  | { type: 'error'; reason: 'error' | 'aborted'; error: AssistantMessage };
-
-interface AssistantMessageEventStream extends AsyncIterable<AssistantMessageEvent> {
-  result(): Promise<AssistantMessage>;
-}
-
-class EventStream<TEvent, TResult = TEvent> implements AsyncIterable<TEvent> {
-  private readonly queue: TEvent[] = [];
-  private readonly waiting: Array<(result: IteratorResult<TEvent>) => void> = [];
-  private done = false;
-  private readonly finalResultPromise: Promise<TResult>;
-  private resolveFinalResult!: (result: TResult) => void;
-
-  constructor(
-    private readonly isTerminal: (event: TEvent) => boolean,
-    private readonly extractResult: (event: TEvent) => TResult
-  ) {
-    this.finalResultPromise = new Promise<TResult>((resolve) => {
-      this.resolveFinalResult = resolve;
-    });
-  }
-
-  push(event: TEvent): void {
-    if (this.done) {
-      return;
-    }
-
-    if (this.isTerminal(event)) {
-      this.done = true;
-      this.resolveFinalResult(this.extractResult(event));
-    }
-
-    const waiter = this.waiting.shift();
-    if (waiter) {
-      waiter({ value: event, done: false });
-      return;
-    }
-
-    this.queue.push(event);
-  }
-
-  end(result?: TResult): void {
-    this.done = true;
-    if (result !== undefined) {
-      this.resolveFinalResult(result);
-    }
-
-    while (this.waiting.length > 0) {
-      this.waiting.shift()!({ value: undefined as never, done: true });
-    }
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterator<TEvent> {
-    while (true) {
-      if (this.queue.length > 0) {
-        yield this.queue.shift()!;
-        continue;
-      }
-
-      if (this.done) {
-        return;
-      }
-
-      const next = await new Promise<IteratorResult<TEvent>>((resolve) => {
-        this.waiting.push(resolve);
-      });
-
-      if (next.done) {
-        return;
-      }
-
-      yield next.value;
-    }
-  }
-
-  result(): Promise<TResult> {
-    return this.finalResultPromise;
-  }
-}
-
-class DefaultAssistantMessageEventStream
-  extends EventStream<AssistantMessageEvent, AssistantMessage>
-  implements AssistantMessageEventStream
-{
-  constructor() {
-    super(
-      (event) => event.type === 'done' || event.type === 'error',
-      (event) => {
-        if (event.type === 'done') {
-          return event.message;
-        }
-        if (event.type === 'error') {
-          return event.error;
-        }
-        throw new Error('Unexpected terminal event');
-      }
-    );
-  }
-}
-
 export interface AnthropicOptions {
   apiKey: string;
   baseUrl?: string;
@@ -443,9 +221,10 @@ export class AnthropicAdapter {
               } else if (event.content_block?.type === 'tool_use') {
                 const initialInput = event.content_block.input ?? {};
                 const toolCall: ToolCallContent = {
-                  type: 'toolCall',
-                  id: event.content_block.id ?? `tool_${event.index}`,
-                  name: event.content_block.name ?? '',
+                  ...createToolCall(
+                    event.content_block.id ?? `tool_${event.index}`,
+                    event.content_block.name ?? ''
+                  ),
                   arguments: initialInput,
                   rawArguments:
                     Object.keys(initialInput).length > 0 ? JSON.stringify(initialInput) : '',
@@ -752,35 +531,6 @@ function clampThinkingBudget(reasoning: NonNullable<StreamOptions['reasoning']>)
   }
 }
 
-function createAssistantMessage(model: ModelDescriptor): AssistantMessage {
-  return {
-    role: 'assistant',
-    api: model.api,
-    provider: model.provider,
-    model: model.id,
-    content: [],
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    },
-    stopReason: 'stop',
-    timestamp: Date.now(),
-  };
-}
-
-function calculateUsageCost(model: ModelDescriptor, usage: Usage): void {
-  usage.cost.input = ((model.cost?.input ?? 0) / 1_000_000) * usage.input;
-  usage.cost.output = ((model.cost?.output ?? 0) / 1_000_000) * usage.output;
-  usage.cost.cacheRead = ((model.cost?.cacheRead ?? 0) / 1_000_000) * usage.cacheRead;
-  usage.cost.cacheWrite = ((model.cost?.cacheWrite ?? 0) / 1_000_000) * usage.cacheWrite;
-  usage.cost.total =
-    usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-}
-
 function normalizeBaseUrl(baseUrl: string): string {
   const trimmed = baseUrl.replace(/\/+$/, '');
   if (/\/v\d+$/.test(trimmed)) {
@@ -789,76 +539,6 @@ function normalizeBaseUrl(baseUrl: string): string {
   return `${trimmed}/v1`;
 }
 
-function parsePartialJson(raw: string): Record<string, JsonValue | undefined> {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return {};
-  }
-
-  try {
-    return JSON.parse(trimmed) as Record<string, JsonValue | undefined>;
-  } catch {
-    // continue
-  }
-
-  const completed = completePartialJson(trimmed);
-  if (!completed) {
-    return {};
-  }
-
-  try {
-    return JSON.parse(completed) as Record<string, JsonValue | undefined>;
-  } catch {
-    return {};
-  }
-}
-
-function completePartialJson(input: string): string | undefined {
-  let output = input;
-  let inString = false;
-  let escaping = false;
-  const stack: string[] = [];
-
-  for (const char of input) {
-    if (escaping) {
-      escaping = false;
-      continue;
-    }
-
-    if (char === '\\') {
-      escaping = true;
-      continue;
-    }
-
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-
-    if (inString) {
-      continue;
-    }
-
-    if (char === '{') {
-      stack.push('}');
-    } else if (char === '[') {
-      stack.push(']');
-    } else if (char === '}' || char === ']') {
-      stack.pop();
-    }
-  }
-
-  if (inString) {
-    output += '"';
-  }
-
-  while (stack.length > 0) {
-    output += stack.pop();
-  }
-
-  return output;
-}
-
 function parseSseFrame(frame: string): { event?: string; data?: string } | undefined {
   const lines = frame.split('\n');
   const data: string[] = [];
@@ -882,8 +562,4 @@ function parseSseFrame(frame: string): { event?: string; data?: string } | undef
   };
 }
 
-function clone<TValue>(value: TValue): TValue {
-  return JSON.parse(JSON.stringify(value)) as TValue;
-}
-
 export default AnthropicAdapter;
diff --git a/packages/core/__tests__/core.test.ts b/packages/core/__tests__/core.test.ts
new file mode 100644
index 0000000..ffc0f2c
--- /dev/null
+++ b/packages/core/__tests__/core.test.ts
@@ -0,0 +1,135 @@
+import {
+  type AssistantMessage,
+  clone,
+  createAssistantMessage,
+  createAssistantMessageEventStream,
+  type ModelDescriptor,
+  parsePartialJson,
+  transformMessages,
+} from '../src';
+
+function createModel(overrides: Partial<ModelDescriptor> = {}): ModelDescriptor {
+  return {
+    id: 'demo',
+    name: 'Demo',
+    api: 'fake-api',
+    provider: 'fake',
+    baseUrl: 'http://fake.local',
+    input: ['text'],
+    reasoning: false,
+    tools: true,
+    ...overrides,
+  };
+}
+
+function createMessage(overrides: Partial<AssistantMessage> = {}): AssistantMessage {
+  return {
+    ...createAssistantMessage(createModel()),
+    content: [{ type: 'text', text: 'hello' }],
+    ...overrides,
+  };
+}
+
+describe('@agentic-kit/core', () => {
+  it('resolves stream results from terminal done events', async () => {
+    const stream = createAssistantMessageEventStream();
+    const message = createMessage();
+
+    queueMicrotask(() => {
+      stream.push({ type: 'start', partial: message });
+      stream.push({ type: 'done', reason: 'stop', message });
+    });
+
+    const eventTypes: string[] = [];
+    for await (const event of stream) {
+      eventTypes.push(event.type);
+    }
+
+    await expect(stream.result()).resolves.toBe(message);
+    expect(eventTypes).toEqual(['start', 'done']);
+  });
+
+  it('resolves stream results from terminal error events', async () => {
+    const stream = createAssistantMessageEventStream();
+    const failure = createMessage({
+      stopReason: 'error',
+      errorMessage: 'failed',
+      content: [],
+    });
+
+    queueMicrotask(() => {
+      stream.push({ type: 'error', reason: 'error', error: failure });
+    });
+
+    for await (const _event of stream) {
+      // Drain stream.
+    }
+
+    await expect(stream.result()).resolves.toBe(failure);
+  });
+
+  it('parses incomplete streamed JSON arguments', () => {
+    expect(parsePartialJson('{"city":"Paris"}')).toEqual({ city: 'Paris' });
+    expect(parsePartialJson('{"city":"Pa')).toEqual({ city: 'Pa' });
+    expect(parsePartialJson('')).toEqual({});
+    expect(parsePartialJson('  ')).toEqual({});
+  });
+
+  it('completes nested streamed JSON arguments', () => {
+    expect(parsePartialJson('{"filters":{"city":"Paris","tags":["food"')).toEqual({
+      filters: { city: 'Paris', tags: ['food'] },
+    });
+  });
+
+  it('handles escaped quotes in streamed JSON strings', () => {
+    expect(parsePartialJson('{"text":"say \\"he')).toEqual({ text: 'say "he' });
+  });
+
+  it('returns an empty object for non-object or malformed JSON arguments', () => {
+    expect(parsePartialJson('[{"city":"Paris"}]')).toEqual({});
+    expect(parsePartialJson('"Paris"')).toEqual({});
+    expect(parsePartialJson('42')).toEqual({});
+    expect(parsePartialJson('null')).toEqual({});
+    expect(parsePartialJson('{"a":[}')).toEqual({});
+  });
+
+  it('clones JSON-shaped values using JSON serialization semantics', () => {
+    expect(clone({ city: 'Paris', missing: undefined })).toEqual({ city: 'Paris' });
+  });
+
+  it('rewrites stricter-provider tool call ids and matching tool results', () => {
+    const transformed = transformMessages(
+      [
+        createMessage({
+          stopReason: 'toolUse',
+          content: [
+            {
+              type: 'toolCall',
+              id: 'call|needs-normalizing',
+              name: 'lookup',
+              arguments: { city: 'Paris' },
+            },
+          ],
+        }),
+        {
+          role: 'toolResult',
+          toolCallId: 'call|needs-normalizing',
+          toolName: 'lookup',
+          content: [{ type: 'text', text: 'ok' }],
+          isError: false,
+          timestamp: Date.now(),
+        },
+      ],
+      createModel({ api: 'anthropic-messages', provider: 'anthropic' })
+    );
+
+    expect(transformed[0]).toMatchObject({
+      role: 'assistant',
+      content: [{ type: 'toolCall', id: 'call_needs-normalizing' }],
+    });
+    expect(transformed[1]).toMatchObject({
+      role: 'toolResult',
+      toolCallId: 'call_needs-normalizing',
+    });
+  });
+});
diff --git a/packages/core/__tests__/tsconfig.json b/packages/core/__tests__/tsconfig.json
new file mode 100644
index 0000000..6c4fda5
--- /dev/null
+++ b/packages/core/__tests__/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "rootDir": "..",
+    "types": ["jest", "node"]
+  },
+  "include": ["./**/*.ts", "../src/**/*.ts"],
+  "exclude": ["../dist", "../node_modules"]
+}
diff --git a/packages/core/jest.config.js b/packages/core/jest.config.js
new file mode 100644
index 0000000..7f2122a
--- /dev/null
+++ b/packages/core/jest.config.js
@@ -0,0 +1,22 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        babelConfig: false,
+        tsconfig: '__tests__/tsconfig.json',
+      },
+    ],
+  },
+  transformIgnorePatterns: [`/node_modules/*`],
+  testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  modulePathIgnorePatterns: ['dist/*'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+    '^@agentic-kit/core$': '<rootDir>/src',
+  },
+};
diff --git a/packages/core/package.json b/packages/core/package.json
new file mode 100644
index 0000000..6196f08
--- /dev/null
+++ b/packages/core/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "@agentic-kit/core",
+  "version": "1.0.3",
+  "author": "Dan Lynch <pyramation@gmail.com>",
+  "description": "Core protocol types and stream primitives for agentic-kit",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/agentic-kit",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/agentic-kit"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/agentic-kit/issues"
+  },
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.esm.json && cp ../../LICENSE dist/LICENSE && cp package.json dist/package.json",
+    "build:dev": "tsc -p tsconfig.json --watch",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "keywords": []
+}
diff --git a/packages/core/src/event-stream.ts b/packages/core/src/event-stream.ts
new file mode 100644
index 0000000..fd73bc7
--- /dev/null
+++ b/packages/core/src/event-stream.ts
@@ -0,0 +1,105 @@
+import type {
+  AssistantMessage,
+  AssistantMessageEvent,
+  AssistantMessageEventStream,
+} from './types.js';
+
+export class EventStream<TEvent, TResult = TEvent> implements AsyncIterable<TEvent> {
+  private readonly queue: TEvent[] = [];
+  private readonly waiting: Array<(result: IteratorResult<TEvent>) => void> = [];
+  private done = false;
+  private readonly finalResultPromise: Promise<TResult>;
+  private resolveFinalResult!: (value: TResult) => void;
+
+  constructor(
+    private readonly isTerminal: (event: TEvent) => boolean,
+    private readonly extractResult: (event: TEvent) => TResult
+  ) {
+    this.finalResultPromise = new Promise<TResult>((resolve) => {
+      this.resolveFinalResult = resolve;
+    });
+  }
+
+  push(event: TEvent): void {
+    if (this.done) {
+      return;
+    }
+
+    if (this.isTerminal(event)) {
+      this.done = true;
+      this.resolveFinalResult(this.extractResult(event));
+    }
+
+    const waiter = this.waiting.shift();
+    if (waiter) {
+      waiter({ value: event, done: false });
+      return;
+    }
+
+    this.queue.push(event);
+  }
+
+  end(result?: TResult): void {
+    this.done = true;
+    if (result !== undefined) {
+      this.resolveFinalResult(result);
+    }
+
+    while (this.waiting.length > 0) {
+      this.waiting.shift()!({ value: undefined as never, done: true });
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncIterator<TEvent> {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift()!;
+        continue;
+      }
+
+      if (this.done) {
+        return;
+      }
+
+      const next = await new Promise<IteratorResult<TEvent>>((resolve) => {
+        this.waiting.push(resolve);
+      });
+
+      if (next.done) {
+        return;
+      }
+
+      yield next.value;
+    }
+  }
+
+  result(): Promise<TResult> {
+    return this.finalResultPromise;
+  }
+}
+
+export class DefaultAssistantMessageEventStream
+  extends EventStream<AssistantMessageEvent, AssistantMessage>
+  implements AssistantMessageEventStream
+{
+  constructor() {
+    super(
+      (event) => event.type === 'done' || event.type === 'error',
+      (event) => {
+        if (event.type === 'done') {
+          return event.message;
+        }
+
+        if (event.type === 'error') {
+          return event.error;
+        }
+
+        throw new Error('Unexpected terminal event');
+      }
+    );
+  }
+}
+
+export function createAssistantMessageEventStream(): DefaultAssistantMessageEventStream {
+  return new DefaultAssistantMessageEventStream();
+}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
new file mode 100644
index 0000000..610680d
--- /dev/null
+++ b/packages/core/src/index.ts
@@ -0,0 +1,5 @@
+export * from './event-stream.js';
+export * from './json.js';
+export * from './messages.js';
+export * from './transform-messages.js';
+export * from './types.js';
diff --git a/packages/core/src/json.ts b/packages/core/src/json.ts
new file mode 100644
index 0000000..c36889c
--- /dev/null
+++ b/packages/core/src/json.ts
@@ -0,0 +1,90 @@
+import type { JsonObject } from './types.js';
+
+export function parsePartialJson(raw: string): JsonObject {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return {};
+  }
+
+  const parsed = parseJsonObject(trimmed);
+  if (parsed) {
+    return parsed;
+  }
+
+  const completed = completePartialJson(trimmed);
+  if (!completed) {
+    return {};
+  }
+
+  return parseJsonObject(completed) ?? {};
+}
+
+function parseJsonObject(raw: string): JsonObject | undefined {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return isJsonObject(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function completePartialJson(input: string): string | undefined {
+  let output = input;
+  let inString = false;
+  let escaping = false;
+  const stack: string[] = [];
+
+  for (const char of input) {
+    if (escaping) {
+      escaping = false;
+      continue;
+    }
+
+    if (inString && char === '\\') {
+      escaping = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) {
+      continue;
+    }
+
+    if (char === '{') {
+      stack.push('}');
+    } else if (char === '[') {
+      stack.push(']');
+    } else if (char === '}' || char === ']') {
+      const expected = stack.pop();
+      if (expected !== char) {
+        return undefined;
+      }
+    }
+  }
+
+  if (escaping) {
+    return undefined;
+  }
+
+  if (inString) {
+    output += '"';
+  }
+
+  while (stack.length > 0) {
+    output += stack.pop();
+  }
+
+  return output;
+}
+
+function isJsonObject(value: unknown): value is JsonObject {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function clone<TValue>(value: TValue): TValue {
+  return JSON.parse(JSON.stringify(value)) as TValue;
+}
diff --git a/packages/core/src/messages.ts b/packages/core/src/messages.ts
new file mode 100644
index 0000000..c958f6b
--- /dev/null
+++ b/packages/core/src/messages.ts
@@ -0,0 +1,116 @@
+import { clone } from './json.js';
+import type {
+  AssistantMessage,
+  Context,
+  ImageContent,
+  Message,
+  ModelDescriptor,
+  TextContent,
+  ToolCallContent,
+  ToolResultMessage,
+  Usage,
+  UserMessage,
+} from './types.js';
+
+export function createEmptyUsage(): Usage {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      total: 0,
+    },
+  };
+}
+
+export function calculateUsageCost(model: ModelDescriptor, usage: Usage): Usage['cost'] {
+  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;
+}
+
+export function createAssistantMessage(model: ModelDescriptor): AssistantMessage {
+  return {
+    role: 'assistant',
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    content: [],
+    usage: createEmptyUsage(),
+    stopReason: 'stop',
+    timestamp: Date.now(),
+  };
+}
+
+export function createTextContent(text = ''): TextContent {
+  return { type: 'text', text };
+}
+
+export function createImageContent(data: string, mimeType: string): ImageContent {
+  return { type: 'image', data, mimeType };
+}
+
+export function createToolCall(id: string, name: string): ToolCallContent {
+  return { type: 'toolCall', id, name, arguments: {}, rawArguments: '' };
+}
+
+export function createUserMessage(content: UserMessage['content']): UserMessage {
+  return {
+    role: 'user',
+    content,
+    timestamp: Date.now(),
+  };
+}
+
+export function createToolResultMessage(
+  toolCallId: string,
+  toolName: string,
+  content: ToolResultMessage['content'],
+  isError = false
+): ToolResultMessage {
+  return {
+    role: 'toolResult',
+    toolCallId,
+    toolName,
+    content,
+    isError,
+    timestamp: Date.now(),
+  };
+}
+
+export function getMessageText(message: AssistantMessage): string {
+  return message.content
+    .filter((block): block is TextContent => block.type === 'text')
+    .map((block) => block.text)
+    .join('');
+}
+
+export function cloneMessage<TMessage extends Message>(message: TMessage): TMessage {
+  return clone(message);
+}
+
+export function normalizeContext(context: Context): Context {
+  return {
+    systemPrompt: context.systemPrompt,
+    tools: context.tools ?? [],
+    messages: context.messages.map((message) => ensureTimestamp(cloneMessage(message))),
+  };
+}
+
+function ensureTimestamp<TMessage extends Message>(message: TMessage): TMessage {
+  if (typeof message.timestamp !== 'number') {
+    (message as Message).timestamp = Date.now();
+  }
+  return message;
+}
diff --git a/packages/core/src/transform-messages.ts b/packages/core/src/transform-messages.ts
new file mode 100644
index 0000000..589f325
--- /dev/null
+++ b/packages/core/src/transform-messages.ts
@@ -0,0 +1,193 @@
+import type {
+  Message,
+  ModelDescriptor,
+  TextContent,
+  ThinkingContent,
+  ToolCallContent,
+  ToolResultMessage,
+} from './types.js';
+
+export function transformMessages(messages: Message[], model: ModelDescriptor): Message[] {
+  const toolCallIdMap = new Map<string, string>();
+
+  const transformed: Message[] = messages.flatMap((message): 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: Array<TextContent | ThinkingContent | ToolCallContent> = message.content.flatMap(
+      (block): Array<TextContent | ThinkingContent | ToolCallContent> => {
+        if (block.type === 'thinking') {
+          if (sameModel) {
+            return [block];
+          }
+
+          if (!block.thinking.trim()) {
+            return [];
+          }
+
+          const thinkingAsText: TextContent = {
+            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: ToolCallContent =
+            normalizedId === block.id ? block : { ...block, id: normalizedId };
+          return [toolCall];
+        }
+
+        return [block];
+      }
+    );
+
+    return [{ ...message, content }];
+  });
+
+  return insertSyntheticToolResults(transformed);
+}
+
+function insertSyntheticToolResults(messages: Message[]): Message[] {
+  const result: Message[] = [];
+  let pendingToolCalls: ToolCallContent[] = [];
+  let seenToolResults = new Set<string>();
+
+  for (const message of messages) {
+    if (message.role === 'assistant') {
+      flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
+
+      pendingToolCalls = message.content.filter(
+        (block): block is ToolCallContent => block.type === 'toolCall'
+      );
+      seenToolResults = new Set<string>();
+      result.push(message);
+      continue;
+    }
+
+    if (message.role === 'toolResult') {
+      seenToolResults.add(message.toolCallId);
+      result.push(message);
+      continue;
+    }
+
+    flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
+    pendingToolCalls = [];
+    seenToolResults = new Set<string>();
+    result.push(message);
+  }
+
+  flushPendingToolCalls(result, pendingToolCalls, seenToolResults);
+  return result;
+}
+
+function flushPendingToolCalls(
+  result: Message[],
+  pendingToolCalls: ToolCallContent[],
+  seenToolResults: Set<string>
+): void {
+  if (pendingToolCalls.length === 0) {
+    return;
+  }
+
+  for (const toolCall of pendingToolCalls) {
+    if (seenToolResults.has(toolCall.id)) {
+      continue;
+    }
+
+    const synthetic: ToolResultMessage = {
+      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: string, model: ModelDescriptor): string {
+  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: ModelDescriptor): 'passthrough' | 'safe64' | 'mistral9' {
+  if (model.provider === 'anthropic' || model.api === 'anthropic-messages') {
+    return 'safe64';
+  }
+
+  return 'passthrough';
+}
+
+function stableId(input: string, length: number, pattern: RegExp): string {
+  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: string, length: number): string {
+  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');
+}
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
new file mode 100644
index 0000000..00b432c
--- /dev/null
+++ b/packages/core/src/types.ts
@@ -0,0 +1,215 @@
+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;
+}
+
+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>;
+}
diff --git a/packages/core/tsconfig.esm.json b/packages/core/tsconfig.esm.json
new file mode 100644
index 0000000..800d750
--- /dev/null
+++ b/packages/core/tsconfig.esm.json
@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "module": "es2022",
+    "rootDir": "src/",
+    "declaration": false
+  }
+}
diff --git a/packages/core/tsconfig.json b/packages/core/tsconfig.json
new file mode 100644
index 0000000..1a9d569
--- /dev/null
+++ b/packages/core/tsconfig.json
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src/"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules", "**/*.spec.*", "**/*.test.*"]
+}
diff --git a/packages/ollama/package.json b/packages/ollama/package.json
index 3352afc..14ef8be 100644
--- a/packages/ollama/package.json
+++ b/packages/ollama/package.json
@@ -33,6 +33,7 @@
   },
   "keywords": [],
   "dependencies": {
+    "@agentic-kit/core": "workspace:*",
     "cross-fetch": "^4.1.0"
   }
 }
diff --git a/packages/ollama/src/index.ts b/packages/ollama/src/index.ts
index 1fe5ba9..9344282 100644
--- a/packages/ollama/src/index.ts
+++ b/packages/ollama/src/index.ts
@@ -1,216 +1,19 @@
+import {
+  type AssistantMessageEventStream,
+  clone,
+  type Context,
+  createAssistantMessage,
+  DefaultAssistantMessageEventStream,
+  getMessageText,
+  type ImageContent,
+  type Message,
+  type ModelDescriptor,
+  type StreamOptions,
+  type TextContent,
+  type ThinkingContent,
+} from '@agentic-kit/core';
 import fetch from 'cross-fetch';
 
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
-
-interface JsonObject {
-  [key: string]: JsonValue | undefined;
-}
-
-interface ModelDescriptor {
-  id: string;
-  name: string;
-  api: string;
-  provider: string;
-  baseUrl: string;
-  input: Array<'text' | 'image'>;
-  reasoning: boolean;
-  tools?: boolean;
-  contextWindow?: number;
-  maxOutputTokens?: number;
-  headers?: Record<string, string>;
-}
-
-interface TextContent {
-  type: 'text';
-  text: string;
-}
-
-interface ImageContent {
-  type: 'image';
-  data: string;
-  mimeType: string;
-}
-
-interface ThinkingContent {
-  type: 'thinking';
-  thinking: string;
-}
-
-interface ToolCallContent {
-  type: 'toolCall';
-  id: string;
-  name: string;
-  arguments: Record<string, JsonValue | undefined>;
-}
-
-interface Usage {
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheWrite: number;
-  totalTokens: number;
-  cost: {
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-    total: number;
-  };
-}
-
-type Message =
-  | {
-      role: 'user';
-      content: string | Array<TextContent | ImageContent>;
-      timestamp: number;
-    }
-  | {
-      role: 'assistant';
-      content: Array<TextContent | ThinkingContent | ToolCallContent>;
-      api: string;
-      provider: string;
-      model: string;
-      usage: Usage;
-      stopReason: 'stop' | 'length' | 'toolUse' | 'error' | 'aborted';
-      errorMessage?: string;
-      timestamp: number;
-    }
-  | {
-      role: 'toolResult';
-      toolCallId: string;
-      toolName: string;
-      content: Array<TextContent | ImageContent>;
-      isError: boolean;
-      details?: unknown;
-      timestamp: number;
-    };
-
-interface Context {
-  systemPrompt?: string;
-  messages: Message[];
-}
-
-interface StreamOptions {
-  maxTokens?: number;
-  signal?: AbortSignal;
-  temperature?: number;
-}
-
-type AssistantMessage = Extract<Message, { role: 'assistant' }>;
-
-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: 'stop' | 'length' | 'toolUse'; message: AssistantMessage }
-  | { type: 'error'; reason: 'error' | 'aborted'; error: AssistantMessage };
-
-interface AssistantMessageEventStream extends AsyncIterable<AssistantMessageEvent> {
-  result(): Promise<AssistantMessage>;
-}
-
-class EventStream<TEvent, TResult = TEvent> implements AsyncIterable<TEvent> {
-  private readonly queue: TEvent[] = [];
-  private readonly waiting: Array<(result: IteratorResult<TEvent>) => void> = [];
-  private done = false;
-  private readonly finalResultPromise: Promise<TResult>;
-  private resolveFinalResult!: (result: TResult) => void;
-
-  constructor(
-    private readonly isTerminal: (event: TEvent) => boolean,
-    private readonly extractResult: (event: TEvent) => TResult
-  ) {
-    this.finalResultPromise = new Promise<TResult>((resolve) => {
-      this.resolveFinalResult = resolve;
-    });
-  }
-
-  push(event: TEvent): void {
-    if (this.done) {
-      return;
-    }
-
-    if (this.isTerminal(event)) {
-      this.done = true;
-      this.resolveFinalResult(this.extractResult(event));
-    }
-
-    const waiter = this.waiting.shift();
-    if (waiter) {
-      waiter({ value: event, done: false });
-      return;
-    }
-
-    this.queue.push(event);
-  }
-
-  end(result?: TResult): void {
-    this.done = true;
-    if (result !== undefined) {
-      this.resolveFinalResult(result);
-    }
-
-    while (this.waiting.length > 0) {
-      this.waiting.shift()!({ value: undefined as never, done: true });
-    }
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterator<TEvent> {
-    while (true) {
-      if (this.queue.length > 0) {
-        yield this.queue.shift()!;
-        continue;
-      }
-
-      if (this.done) {
-        return;
-      }
-
-      const next = await new Promise<IteratorResult<TEvent>>((resolve) => {
-        this.waiting.push(resolve);
-      });
-
-      if (next.done) {
-        return;
-      }
-
-      yield next.value;
-    }
-  }
-
-  result(): Promise<TResult> {
-    return this.finalResultPromise;
-  }
-}
-
-class DefaultAssistantMessageEventStream
-  extends EventStream<AssistantMessageEvent, AssistantMessage>
-  implements AssistantMessageEventStream
-{
-  constructor() {
-    super(
-      (event) => event.type === 'done' || event.type === 'error',
-      (event) => {
-        if (event.type === 'done') {
-          return event.message;
-        }
-        if (event.type === 'error') {
-          return event.error;
-        }
-        throw new Error('Unexpected terminal event');
-      }
-    );
-  }
-}
-
 export interface ChatMessage {
   role: 'system' | 'user' | 'assistant';
   content: string;
@@ -340,10 +143,7 @@ export class OllamaClient {
     }
 
     const message = await response.result();
-    return message.content
-      .filter((block): block is TextContent => block.type === 'text')
-      .map((block) => block.text)
-      .join('');
+    return getMessageText(message);
   }
 }
 
@@ -612,26 +412,6 @@ function toOllamaMessages(context: Context): Array<{ role: string; content: stri
   return messages;
 }
 
-function createAssistantMessage(model: ModelDescriptor): AssistantMessage {
-  return {
-    role: 'assistant',
-    api: model.api,
-    provider: model.provider,
-    model: model.id,
-    content: [],
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    },
-    stopReason: 'stop',
-    timestamp: Date.now(),
-  };
-}
-
 function legacyInputToContext(input: GenerateInput): Context {
   const messages: Message[] = input.messages
     ? input.messages
@@ -669,10 +449,6 @@ function legacyInputToContext(input: GenerateInput): Context {
   };
 }
 
-function clone<TValue>(value: TValue): TValue {
-  return JSON.parse(JSON.stringify(value)) as TValue;
-}
-
 async function* iterateResponseBody(
   body: NonNullable<Response['body']>
 ): AsyncGenerator<Uint8Array, void, void> {
diff --git a/packages/openai/package.json b/packages/openai/package.json
index ef5d29d..a025e42 100644
--- a/packages/openai/package.json
+++ b/packages/openai/package.json
@@ -30,6 +30,7 @@
   },
   "keywords": [],
   "dependencies": {
+    "@agentic-kit/core": "workspace:*",
     "cross-fetch": "^4.1.0"
   }
 }
diff --git a/packages/openai/src/index.ts b/packages/openai/src/index.ts
index 365a76d..7500152 100644
--- a/packages/openai/src/index.ts
+++ b/packages/openai/src/index.ts
@@ -1,257 +1,24 @@
+import {
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  calculateUsageCost,
+  clone,
+  type Context,
+  createAssistantMessage,
+  createToolCall,
+  DefaultAssistantMessageEventStream,
+  type Message,
+  type ModelDescriptor,
+  type OpenAICompatibleCompat,
+  parsePartialJson,
+  type StreamOptions,
+  type TextContent,
+  type ThinkingContent,
+  type ToolCallContent,
+  type Usage,
+} from '@agentic-kit/core';
 import fetch from 'cross-fetch';
 
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
-
-interface JsonObject {
-  [key: string]: JsonValue | undefined;
-}
-
-interface JsonSchema {
-  additionalProperties?: boolean | JsonSchema;
-  description?: string;
-  enum?: JsonValue[];
-  items?: JsonSchema | JsonSchema[];
-  properties?: Record<string, JsonSchema>;
-  required?: string[];
-  type?: string | string[];
-}
-
-interface OpenAICompatibleCompat {
-  maxTokensField?: 'max_completion_tokens' | 'max_tokens';
-  reasoningFormat?: 'none' | 'openai';
-  supportsReasoningEffort?: boolean;
-  supportsStrictToolSchema?: boolean;
-  supportsUsageInStreaming?: boolean;
-  toolCallIdFormat?: 'passthrough' | 'safe64' | 'mistral9';
-  requiresToolResultName?: boolean;
-}
-
-interface ModelDescriptor {
-  id: string;
-  name: string;
-  api: string;
-  provider: string;
-  baseUrl: string;
-  input: Array<'text' | 'image'>;
-  reasoning: boolean;
-  tools?: boolean;
-  contextWindow?: number;
-  maxOutputTokens?: number;
-  cost?: {
-    input?: number;
-    output?: number;
-    cacheRead?: number;
-    cacheWrite?: number;
-  };
-  headers?: Record<string, string>;
-  compat?: OpenAICompatibleCompat;
-}
-
-interface TextContent {
-  type: 'text';
-  text: string;
-}
-
-interface ImageContent {
-  type: 'image';
-  data: string;
-  mimeType: string;
-}
-
-interface ThinkingContent {
-  type: 'thinking';
-  thinking: string;
-  signature?: string;
-}
-
-interface ToolCallContent {
-  type: 'toolCall';
-  id: string;
-  name: string;
-  arguments: Record<string, JsonValue | undefined>;
-  rawArguments?: string;
-}
-
-type Message =
-  | {
-      role: 'user';
-      content: string | Array<TextContent | ImageContent>;
-      timestamp: number;
-    }
-  | {
-      role: 'assistant';
-      content: Array<TextContent | ThinkingContent | ToolCallContent>;
-      api: string;
-      provider: string;
-      model: string;
-      usage: Usage;
-      stopReason: 'stop' | 'length' | 'toolUse' | 'error' | 'aborted';
-      errorMessage?: string;
-      timestamp: number;
-    }
-  | {
-      role: 'toolResult';
-      toolCallId: string;
-      toolName: string;
-      content: Array<TextContent | ImageContent>;
-      isError: boolean;
-      details?: unknown;
-      timestamp: number;
-    };
-
-interface ToolDefinition {
-  name: string;
-  description: string;
-  parameters: JsonSchema;
-}
-
-interface Context {
-  systemPrompt?: string;
-  messages: Message[];
-  tools?: ToolDefinition[];
-}
-
-interface StreamOptions {
-  apiKey?: string;
-  headers?: Record<string, string>;
-  maxTokens?: number;
-  onPayload?: (payload: unknown) => void;
-  reasoning?: 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
-  signal?: AbortSignal;
-  temperature?: number;
-}
-
-interface Usage {
-  input: number;
-  output: number;
-  cacheRead: number;
-  cacheWrite: number;
-  totalTokens: number;
-  cost: {
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-    total: number;
-  };
-}
-
-type AssistantMessage =
-  Extract<Message, { role: 'assistant' }>;
-
-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: 'stop' | 'length' | 'toolUse'; message: AssistantMessage }
-  | { type: 'error'; reason: 'error' | 'aborted'; error: AssistantMessage };
-
-interface AssistantMessageEventStream extends AsyncIterable<AssistantMessageEvent> {
-  result(): Promise<AssistantMessage>;
-}
-
-class EventStream<TEvent, TResult = TEvent> implements AsyncIterable<TEvent> {
-  private readonly queue: TEvent[] = [];
-  private readonly waiting: Array<(result: IteratorResult<TEvent>) => void> = [];
-  private done = false;
-  private readonly finalResultPromise: Promise<TResult>;
-  private resolveFinalResult!: (result: TResult) => void;
-
-  constructor(
-    private readonly isTerminal: (event: TEvent) => boolean,
-    private readonly extractResult: (event: TEvent) => TResult
-  ) {
-    this.finalResultPromise = new Promise<TResult>((resolve) => {
-      this.resolveFinalResult = resolve;
-    });
-  }
-
-  push(event: TEvent): void {
-    if (this.done) {
-      return;
-    }
-
-    if (this.isTerminal(event)) {
-      this.done = true;
-      this.resolveFinalResult(this.extractResult(event));
-    }
-
-    const waiter = this.waiting.shift();
-    if (waiter) {
-      waiter({ value: event, done: false });
-      return;
-    }
-
-    this.queue.push(event);
-  }
-
-  end(result?: TResult): void {
-    this.done = true;
-    if (result !== undefined) {
-      this.resolveFinalResult(result);
-    }
-
-    while (this.waiting.length > 0) {
-      this.waiting.shift()!({ value: undefined as never, done: true });
-    }
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterator<TEvent> {
-    while (true) {
-      if (this.queue.length > 0) {
-        yield this.queue.shift()!;
-        continue;
-      }
-
-      if (this.done) {
-        return;
-      }
-
-      const next = await new Promise<IteratorResult<TEvent>>((resolve) => {
-        this.waiting.push(resolve);
-      });
-
-      if (next.done) {
-        return;
-      }
-
-      yield next.value;
-    }
-  }
-
-  result(): Promise<TResult> {
-    return this.finalResultPromise;
-  }
-}
-
-class DefaultAssistantMessageEventStream
-  extends EventStream<AssistantMessageEvent, AssistantMessage>
-  implements AssistantMessageEventStream
-{
-  constructor() {
-    super(
-      (event) => event.type === 'done' || event.type === 'error',
-      (event) => {
-        if (event.type === 'done') {
-          return event.message;
-        }
-        if (event.type === 'error') {
-          return event.error;
-        }
-        throw new Error('Unexpected terminal event');
-      }
-    );
-  }
-}
-
 interface OpenAIModelDefinition extends ModelDescriptor {}
 
 export interface OpenAIOptions {
@@ -572,13 +339,9 @@ export class OpenAIAdapter {
 
               if (contentIndex === undefined) {
                 contentIndex =
-                  output.content.push({
-                    type: 'toolCall',
-                    id: toolDelta.id ?? `tool_${toolIndex}`,
-                    name: toolDelta.function?.name ?? '',
-                    arguments: {},
-                    rawArguments: '',
-                  }) - 1;
+                  output.content.push(
+                    createToolCall(toolDelta.id ?? `tool_${toolIndex}`, toolDelta.function?.name ?? '')
+                  ) - 1;
                 toolIndexMap.set(toolIndex, contentIndex);
                 stream.push({
                   type: 'toolcall_start',
@@ -784,35 +547,6 @@ function toOpenAIMessage(
   };
 }
 
-function createAssistantMessage(model: ModelDescriptor): AssistantMessage {
-  return {
-    role: 'assistant',
-    api: model.api,
-    provider: model.provider,
-    model: model.id,
-    content: [],
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    },
-    stopReason: 'stop',
-    timestamp: Date.now(),
-  };
-}
-
-function calculateUsageCost(model: ModelDescriptor, usage: Usage): void {
-  usage.cost.input = ((model.cost?.input ?? 0) / 1_000_000) * usage.input;
-  usage.cost.output = ((model.cost?.output ?? 0) / 1_000_000) * usage.output;
-  usage.cost.cacheRead = ((model.cost?.cacheRead ?? 0) / 1_000_000) * usage.cacheRead;
-  usage.cost.cacheWrite = ((model.cost?.cacheWrite ?? 0) / 1_000_000) * usage.cacheWrite;
-  usage.cost.total =
-    usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-}
-
 function applyUsage(
   usage: Usage,
   model: ModelDescriptor,
@@ -879,80 +613,6 @@ function normalizeBaseUrl(baseUrl: string): string {
   return `${trimmed}/v1`;
 }
 
-function parsePartialJson(raw: string): Record<string, JsonValue | undefined> {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return {};
-  }
-
-  try {
-    return JSON.parse(trimmed) as Record<string, JsonValue | undefined>;
-  } catch {
-    // continue
-  }
-
-  const completed = completePartialJson(trimmed);
-  if (!completed) {
-    return {};
-  }
-
-  try {
-    return JSON.parse(completed) as Record<string, JsonValue | undefined>;
-  } catch {
-    return {};
-  }
-}
-
-function completePartialJson(input: string): string | undefined {
-  let output = input;
-  let inString = false;
-  let escaping = false;
-  const stack: string[] = [];
-
-  for (const char of input) {
-    if (escaping) {
-      escaping = false;
-      continue;
-    }
-
-    if (char === '\\') {
-      escaping = true;
-      continue;
-    }
-
-    if (char === '"') {
-      inString = !inString;
-      continue;
-    }
-
-    if (inString) {
-      continue;
-    }
-
-    if (char === '{') {
-      stack.push('}');
-    } else if (char === '[') {
-      stack.push(']');
-    } else if (char === '}' || char === ']') {
-      stack.pop();
-    }
-  }
-
-  if (inString) {
-    output += '"';
-  }
-
-  while (stack.length > 0) {
-    output += stack.pop();
-  }
-
-  return output;
-}
-
-function clone<TValue>(value: TValue): TValue {
-  return JSON.parse(JSON.stringify(value)) as TValue;
-}
-
 function firstNonEmpty(...values: Array<string | undefined>): string | undefined {
   return values.find((value) => typeof value === 'string' && value.length > 0);
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 2fad777..6a22c88 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -165,6 +165,9 @@ importers:
 
   packages/agent:
     dependencies:
+      '@agentic-kit/core':
+        specifier: workspace:*
+        version: link:../core/dist
       agentic-kit:
         specifier: workspace:*
         version: link:../agentic-kit/dist
@@ -175,6 +178,9 @@ importers:
       '@agentic-kit/anthropic':
         specifier: workspace:*
         version: link:../anthropic/dist
+      '@agentic-kit/core':
+        specifier: workspace:*
+        version: link:../core/dist
       '@agentic-kit/ollama':
         specifier: workspace:*
         version: link:../ollama/dist
@@ -189,13 +195,22 @@ importers:
 
   packages/anthropic:
     dependencies:
+      '@agentic-kit/core':
+        specifier: workspace:*
+        version: link:../core/dist
       cross-fetch:
         specifier: ^4.1.0
         version: 4.1.0(encoding@0.1.13)
     publishDirectory: dist
 
+  packages/core:
+    publishDirectory: dist
+
   packages/ollama:
     dependencies:
+      '@agentic-kit/core':
+        specifier: workspace:*
+        version: link:../core/dist
       cross-fetch:
         specifier: ^4.1.0
         version: 4.1.0(encoding@0.1.13)
@@ -203,6 +218,9 @@ importers:
 
   packages/openai:
     dependencies:
+      '@agentic-kit/core':
+        specifier: workspace:*
+        version: link:../core/dist
       cross-fetch:
         specifier: ^4.1.0
         version: 4.1.0(encoding@0.1.13)
diff --git a/scripts/typecheck.js b/scripts/typecheck.js
index 5c08dc3..3dd8dae 100644
--- a/scripts/typecheck.js
+++ b/scripts/typecheck.js
@@ -3,6 +3,7 @@
 const { spawnSync } = require('node:child_process');
 
 const packageDirs = [
+  'packages/core',
   'packages/anthropic',
   'packages/openai',
   'packages/ollama',
@@ -17,6 +18,19 @@ const configs = packageDirs.flatMap((dir) => [
 
 const pnpmCommand = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
 
+console.log('[typecheck] packages/core build');
+const coreBuild = spawnSync(pnpmCommand, ['--filter', '@agentic-kit/core', 'run', 'build'], {
+  stdio: 'inherit',
+});
+
+if (coreBuild.error) {
+  throw coreBuild.error;
+}
+
+if ((coreBuild.status ?? 1) !== 0) {
+  process.exit(coreBuild.status ?? 1);
+}
+
 for (const configPath of configs) {
   console.log(`[typecheck] ${configPath}`);
   const result = spawnSync(pnpmCommand, ['exec', 'tsc', '--noEmit', '-p', configPath], {