Harden adapters and expand Ollama live coverage

Author: yyyyaaa

README.md

@@ -27,19 +27,19 @@ cross-provider message normalization, and an optional stateful agent runtime.
 ```bash
 git clone git@github.com:constructive-io/agentic-kit.git
 cd agentic-kit
-yarn install
-yarn build
-yarn test
+pnpm install
+pnpm build
+pnpm test
 ```
 
 ## Usage
 
 ```typescript
-import { complete, getModel } from 'agentic-kit';
+import { complete, getModel } from "agentic-kit";
 
-const model = getModel('openai', 'gpt-4o-mini');
+const model = getModel("openai", "gpt-4o-mini");
 const message = await complete(model!, {
-  messages: [{ role: 'user', content: 'Hello', timestamp: Date.now() }],
+  messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
 });
 
 console.log(message.content);
@@ -48,3 +48,29 @@ console.log(message.content);
 ## Contributing
 
 See individual package READMEs for docs and local dev instructions.
+
+## Testing
+
+Default tests stay deterministic and local:
+
+```bash
+pnpm test
+```
+
+There is also a local-only Ollama live lane that does not hit hosted
+providers. The default root command runs the fast smoke tier:
+
+```bash
+OLLAMA_LIVE_MODEL=qwen3.5:4b pnpm test:live:ollama
+```
+
+Run the broader lane explicitly when you want slower behavioral coverage:
+
+```bash
+OLLAMA_LIVE_MODEL=qwen3.5:4b pnpm test:live:ollama:extended
+```
+
+The Ollama live script performs a preflight against `OLLAMA_BASE_URL` and exits
+cleanly if the local server or requested model is unavailable. If
+`nomic-embed-text:latest` is installed, the lane also exercises local embedding
+generation.

package.json

@@ -18,6 +18,9 @@
     "clean": "pnpm -r run clean",
     "build": "pnpm -r run build",
     "build:dev": "pnpm -r run build:dev",
+    "test": "pnpm -r run test",
+    "test:live:ollama": "pnpm --filter @agentic-kit/ollama run test:live:smoke",
+    "test:live:ollama:extended": "pnpm --filter @agentic-kit/ollama run test:live:extended",
     "lint": "pnpm -r run lint",
     "internal:deps": "makage update-workspace",
     "deps": "pnpm up -r -i -L"

packages/agent/__tests__/agent.test.ts

@@ -1,4 +1,9 @@
-import { createAssistantMessageEventStream, type Context, type ModelDescriptor } from 'agentic-kit';
+import {
+  createAssistantMessageEventStream,
+  type AssistantMessage,
+  type Context,
+  type ModelDescriptor,
+} from 'agentic-kit';
 
 import { Agent } from '../src';
 
@@ -147,4 +152,180 @@ describe('@agentic-kit/agent', () => {
       content: [{ type: 'text', text: 'done' }],
     });
   });
+
+  it('turns tool argument validation failures into error tool results and continues', async () => {
+    const responses = [
+      createAssistantResponse({
+        stopReason: 'toolUse',
+        content: [{ type: 'toolCall', id: 'tool_1', name: 'echo', arguments: {} }],
+      }),
+      createAssistantResponse({
+        stopReason: 'stop',
+        content: [{ type: 'text', text: 'recovered' }],
+      }),
+    ];
+
+    let callIndex = 0;
+    const agent = new Agent({
+      initialState: { model: createModel() },
+      streamFn: () => streamMessage(responses[callIndex++]),
+    });
+
+    const execute = jest.fn(async () => ({
+      content: [{ type: 'text' as const, text: 'should not run' }],
+    }));
+
+    agent.setTools([
+      {
+        name: 'echo',
+        label: 'Echo',
+        description: 'Echo text',
+        parameters: {
+          type: 'object',
+          properties: {
+            text: { type: 'string' },
+          },
+          required: ['text'],
+        },
+        execute,
+      },
+    ]);
+
+    await agent.prompt('hello');
+
+    expect(execute).not.toHaveBeenCalled();
+    expect(agent.state.messages[2]).toMatchObject({
+      role: 'toolResult',
+      toolName: 'echo',
+      isError: true,
+    });
+    expect(agent.state.messages[2].content[0]).toMatchObject({
+      type: 'text',
+      text: expect.stringContaining('Tool argument validation failed'),
+    });
+    expect(agent.state.messages[3]).toMatchObject({
+      role: 'assistant',
+      content: [{ type: 'text', text: 'recovered' }],
+    });
+  });
+
+  it('records aborted assistant turns when the active stream is cancelled', async () => {
+    const agent = new Agent({
+      initialState: { model: createModel() },
+      streamFn: (_model: ModelDescriptor, _context: Context, options) => {
+        const stream = createAssistantMessageEventStream();
+        const partial = createAssistantResponse({
+          stopReason: 'stop',
+          content: [{ type: 'text', text: '' }],
+        });
+
+        queueMicrotask(() => {
+          stream.push({ type: 'start', partial });
+
+          options?.signal?.addEventListener(
+            'abort',
+            () => {
+              const aborted = createAssistantResponse({
+                stopReason: 'aborted',
+                errorMessage: 'aborted by test',
+                content: [],
+              });
+              stream.push({ type: 'error', reason: 'aborted', error: aborted });
+              stream.end(aborted);
+            },
+            { once: true }
+          );
+        });
+
+        return stream;
+      },
+    });
+
+    const pending = agent.prompt('slow');
+    setTimeout(() => agent.abort(), 0);
+    await pending;
+
+    expect(agent.state.error).toBe('aborted by test');
+    expect(agent.state.messages.at(-1)).toMatchObject({
+      role: 'assistant',
+      stopReason: 'aborted',
+      errorMessage: 'aborted by test',
+    });
+    expect(agent.state.isStreaming).toBe(false);
+    expect(agent.state.streamMessage).toBeNull();
+  });
 });
+
+function createAssistantResponse(overrides: Partial<AssistantMessage>): AssistantMessage {
+  return {
+    ...createAssistantResponseBase(),
+    ...overrides,
+  };
+}
+
+function createAssistantResponseBase(): AssistantMessage {
+  return {
+    role: 'assistant' as const,
+    api: 'fake',
+    provider: 'fake',
+    model: 'demo',
+    usage: {
+      input: 1,
+      output: 1,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 2,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    },
+    stopReason: 'stop' as const,
+    timestamp: Date.now(),
+    content: [] as AssistantMessage['content'],
+  };
+}
+
+function streamMessage(message: AssistantMessage) {
+  const stream = createAssistantMessageEventStream();
+
+  queueMicrotask(() => {
+    stream.push({ type: 'start', partial: message });
+    if (message.content[0]?.type === 'toolCall') {
+      stream.push({
+        type: 'toolcall_start',
+        contentIndex: 0,
+        partial: message,
+      });
+      stream.push({
+        type: 'toolcall_end',
+        contentIndex: 0,
+        toolCall: message.content[0],
+        partial: message,
+      });
+    } else {
+      stream.push({
+        type: 'text_start',
+        contentIndex: 0,
+        partial: message,
+      });
+      stream.push({
+        type: 'text_delta',
+        contentIndex: 0,
+        delta: message.content[0]?.type === 'text' ? message.content[0].text : '',
+        partial: message,
+      });
+      stream.push({
+        type: 'text_end',
+        contentIndex: 0,
+        content: message.content[0]?.type === 'text' ? message.content[0].text : '',
+        partial: message,
+      });
+    }
+    stream.push({
+      type: 'done',
+      reason: message.stopReason === 'toolUse' ? 'toolUse' : 'stop',
+      message,
+    });
+    stream.end(message);
+  });
+
+  return stream;
+}

packages/agentic-kit/__tests__/adapter.test.ts

@@ -71,6 +71,85 @@ describe('agentic-kit core', () => {
     });
   });
 
+  it('drops aborted assistant turns and rewrites tool result ids for stricter providers', () => {
+    const sourceModel = createFakeModel();
+    const targetModel: ModelDescriptor = {
+      ...sourceModel,
+      provider: 'anthropic',
+      api: 'anthropic-messages',
+      id: 'claude-demo',
+    };
+
+    const transformed = transformMessages(
+      [
+        {
+          role: 'assistant',
+          api: sourceModel.api,
+          provider: sourceModel.provider,
+          model: sourceModel.id,
+          usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+          },
+          stopReason: 'toolUse',
+          timestamp: Date.now(),
+          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(),
+        },
+        {
+          role: 'assistant',
+          api: sourceModel.api,
+          provider: sourceModel.provider,
+          model: sourceModel.id,
+          usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+          },
+          stopReason: 'aborted',
+          errorMessage: 'cancelled',
+          timestamp: Date.now(),
+          content: [{ type: 'text', text: 'partial' }],
+        },
+      ],
+      targetModel
+    );
+
+    expect(transformed).toHaveLength(2);
+    expect(transformed[0]).toMatchObject({
+      role: 'assistant',
+      content: [
+        {
+          type: 'toolCall',
+          id: 'call_needs-normalizing',
+          name: 'lookup',
+        },
+      ],
+    });
+    expect(transformed[1]).toMatchObject({
+      role: 'toolResult',
+      toolCallId: 'call_needs-normalizing',
+      toolName: 'lookup',
+      isError: false,
+    });
+  });
+
   it('keeps the legacy AgentKit generate API working through structured streams', async () => {
     const provider: ProviderAdapter & { name: string } = {
       api: 'fake-api',
@@ -134,4 +213,31 @@ describe('agentic-kit core', () => {
     expect(chunks).toEqual(['hello world']);
     await expect(kit.generate({ model: 'demo', prompt: 'hi' })).resolves.toBe('hello world');
   });
+
+  it('extracts assistant text from mixed content blocks', () => {
+    const text = getMessageText({
+      role: 'assistant',
+      api: 'fake-api',
+      provider: 'fake',
+      model: 'demo',
+      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(),
+      content: [
+        { type: 'thinking', thinking: 'ignore me' },
+        { type: 'text', text: 'hello ' },
+        { type: 'toolCall', id: 'tool_1', name: 'lookup', arguments: { city: 'Paris' } },
+        { type: 'text', text: 'world' },
+      ],
+    });
+
+    expect(text).toBe('hello world');
+  });
 });