@studio-foundation/runner 0.3.0-beta.1 → 0.3.0-beta.6

package/src/providers/ollama.test.ts

@@ -1,166 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { OllamaProvider } from './ollama.js';
-
-// Capture constructor config so we can assert on baseURL
-let capturedConfig: Record<string, unknown> = {};
-const createMock = vi.fn();
-
-vi.mock('openai', () => ({
-  default: class FakeOpenAI {
-    chat = { completions: { create: createMock } };
-    constructor(config: Record<string, unknown>) {
-      capturedConfig = config;
-    }
-  },
-}));
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  capturedConfig = {};
-});
-
-describe('OllamaProvider', () => {
-  it('has name "ollama"', () => {
-    const provider = new OllamaProvider();
-    expect(provider.name).toBe('ollama');
-  });
-
-  it('passes correct baseURL to SDK (default)', () => {
-    new OllamaProvider();
-    expect(capturedConfig.baseURL).toBe('http://localhost:11434/v1');
-    expect(capturedConfig.apiKey).toBe('ollama');
-  });
-
-  it('passes custom baseURL to SDK', () => {
-    new OllamaProvider('http://my-server:11434');
-    expect(capturedConfig.baseURL).toBe('http://my-server:11434/v1');
-  });
-
-  it('returns content and tool calls on non-streaming call', async () => {
-    createMock.mockResolvedValueOnce({
-      choices: [{
-        message: {
-          content: '{"result":"ok"}',
-          tool_calls: [{
-            id: 'call_1',
-            function: { name: 'repo_manager-read_file', arguments: '{"path":"src/foo.ts"}' },
-          }],
-        },
-        finish_reason: 'tool_calls',
-      }],
-      usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
-    });
-
-    const provider = new OllamaProvider();
-    const result = await provider.call({
-      model: 'llama3.2',
-      messages: [{ role: 'user', content: 'hello' }],
-    });
-
-    expect(result.content).toBe('{"result":"ok"}');
-    expect(result.tool_calls).toHaveLength(1);
-    expect(result.tool_calls![0].name).toBe('repo_manager-read_file');
-    expect(result.tool_calls![0].arguments).toEqual({ path: 'src/foo.ts' });
-    expect(result.usage?.total_tokens).toBe(30);
-  });
-
-  it('streaming: does NOT send stream_options', async () => {
-    async function* fakeStream() {
-      yield { choices: [{ delta: { content: 'hi' }, finish_reason: null }] };
-      yield { choices: [{ delta: {}, finish_reason: 'stop' }] };
-    }
-    createMock.mockReturnValueOnce(fakeStream());
-
-    const provider = new OllamaProvider();
-    await provider.call(
-      { model: 'llama3.2', messages: [{ role: 'user', content: 'hi' }] },
-      () => {},
-    );
-
-    const callArgs = createMock.mock.calls[0][0] as Record<string, unknown>;
-    expect(callArgs.stream_options).toBeUndefined();
-    expect(callArgs.stream).toBe(true);
-  });
-
-  it('streaming: accumulates content and calls onToken', async () => {
-    async function* fakeStream() {
-      yield { choices: [{ delta: { content: 'hello' }, finish_reason: null }] };
-      yield { choices: [{ delta: { content: ' world' }, finish_reason: 'stop' }] };
-    }
-    createMock.mockReturnValueOnce(fakeStream());
-
-    const provider = new OllamaProvider();
-    const tokens: string[] = [];
-    const result = await provider.call(
-      { model: 'llama3.2', messages: [{ role: 'user', content: 'hi' }] },
-      (t) => tokens.push(t),
-    );
-
-    expect(result.content).toBe('hello world');
-    expect(tokens).toEqual(['hello', ' world']);
-  });
-
-  it('wraps ECONNREFUSED with a helpful message', async () => {
-    const connErr = Object.assign(new Error('connect ECONNREFUSED 127.0.0.1:11434'), {
-      code: 'ECONNREFUSED',
-    });
-    createMock.mockRejectedValueOnce(connErr);
-
-    const provider = new OllamaProvider();
-    await expect(
-      provider.call({ model: 'llama3.2', messages: [{ role: 'user', content: 'hi' }] }),
-    ).rejects.toThrow('Ollama is not running at http://localhost:11434');
-  });
-
-  it('wraps ECONNREFUSED from error.cause too', async () => {
-    const cause = Object.assign(new Error('connect ECONNREFUSED'), { code: 'ECONNREFUSED' });
-    const wrappedErr = new Error('fetch failed');
-    (wrappedErr as Error & { cause: unknown }).cause = cause;
-    createMock.mockRejectedValueOnce(wrappedErr);
-
-    const provider = new OllamaProvider();
-    await expect(
-      provider.call({ model: 'llama3.2', messages: [{ role: 'user', content: 'hi' }] }),
-    ).rejects.toThrow('ollama serve');
-  });
-
-  it('streaming: usage is undefined (Ollama does not return usage in streaming)', async () => {
-    async function* fakeStream() {
-      yield { choices: [{ delta: { content: 'hi' }, finish_reason: 'stop' }] };
-    }
-    createMock.mockReturnValueOnce(fakeStream());
-
-    const provider = new OllamaProvider();
-    const result = await provider.call(
-      { model: 'llama3.2', messages: [{ role: 'user', content: 'hi' }] },
-      () => {},
-    );
-
-    expect(result.usage).toBeUndefined();
-  });
-
-  it('aborts streaming when signal fires mid-iteration', async () => {
-    async function* slowStream() {
-      await new Promise((r) => setTimeout(r, 20));
-      yield { choices: [{ delta: { content: 'hello' }, finish_reason: null }] };
-      await new Promise((r) => setTimeout(r, 20));
-      yield { choices: [{ delta: { content: ' world' }, finish_reason: 'stop' }] };
-    }
-    createMock.mockReturnValueOnce(slowStream());
-
-    const provider = new OllamaProvider();
-    const controller = new AbortController();
-
-    const callPromise = provider.call(
-      { model: 'llama3.2', messages: [{ role: 'user', content: 'hi' }] },
-      () => {},
-      controller.signal,
-    );
-
-    setTimeout(() => controller.abort(), 10);
-
-    await expect(callPromise).rejects.toSatisfy(
-      (e: unknown) => e instanceof DOMException && (e as DOMException).name === 'AbortError',
-    );
-  });
-});

package/src/providers/ollama.ts

@@ -1,152 +0,0 @@
-/**
- * Ollama provider — OpenAI-compatible local LLM server
- * Uses the openai npm SDK pointed at Ollama's /v1 endpoint.
- */
-
-import type { LLMRequest, LLMResponse } from '@studio-foundation/contracts';
-import type { Provider } from './provider.js';
-import OpenAI from 'openai';
-import type { ChatCompletionMessageParam, ChatCompletionTool, ChatCompletionChunk } from 'openai/resources/chat/completions';
-
-function isConnectionRefused(err: unknown): boolean {
-  if (!(err instanceof Error)) return false;
-  if ('code' in err && (err as NodeJS.ErrnoException).code === 'ECONNREFUSED') return true;
-  const cause = (err as Error & { cause?: unknown }).cause;
-  if (cause instanceof Error && 'code' in cause && (cause as NodeJS.ErrnoException).code === 'ECONNREFUSED') return true;
-  if (err.message.includes('ECONNREFUSED')) return true;
-  return false;
-}
-
-export class OllamaProvider implements Provider {
-  readonly name = 'ollama';
-  private client: OpenAI;
-  private baseUrl: string;
-
-  constructor(baseUrl = 'http://localhost:11434') {
-    this.baseUrl = baseUrl;
-    this.client = new OpenAI({
-      baseURL: `${baseUrl}/v1`,
-      apiKey: 'ollama', // required by SDK, ignored by Ollama
-    });
-  }
-
-  async call(request: LLMRequest, onToken?: (token: string) => void, signal?: AbortSignal): Promise<LLMResponse> {
-    try {
-      if (onToken) {
-        return await this.callStreaming(request, onToken, signal);
-      }
-      return await this.callNonStreaming(request, signal);
-    } catch (err) {
-      if (isConnectionRefused(err)) {
-        throw new Error(
-          `Ollama is not running at ${this.baseUrl}. Start it with: ollama serve`
-        );
-      }
-      throw err;
-    }
-  }
-
-  private async callNonStreaming(request: LLMRequest, signal?: AbortSignal): Promise<LLMResponse> {
-    const completion = await this.client.chat.completions.create({
-      model: request.model,
-      messages: this.buildMessages(request),
-      tools: this.buildTools(request),
-      temperature: request.temperature,
-      max_tokens: request.max_tokens,
-      response_format: request.json_mode ? { type: 'json_object' } : undefined,
-    }, { signal });
-
-    const choice = completion.choices[0];
-    if (!choice) throw new Error('Ollama returned an empty choices array');
-    const tool_calls = choice.message.tool_calls?.map(tc => ({
-      id: tc.id,
-      name: tc.function.name,
-      arguments: (() => {
-        try { return JSON.parse(tc.function.arguments); }
-        catch { return {}; }
-      })(),
-    })) || [];
-
-    return {
-      content: choice.message.content || '',
-      tool_calls,
-      finish_reason: choice.finish_reason ?? 'stop',
-      usage: completion.usage ? {
-        prompt_tokens: completion.usage.prompt_tokens,
-        completion_tokens: completion.usage.completion_tokens,
-        total_tokens: completion.usage.total_tokens,
-      } : undefined,
-    };
-  }
-
-  private async callStreaming(
-    request: LLMRequest,
-    onToken: (token: string) => void,
-    signal?: AbortSignal,
-  ): Promise<LLMResponse> {
-    // NOTE: No stream_options here — older Ollama versions reject it
-    const stream = this.client.chat.completions.create({
-      model: request.model,
-      messages: this.buildMessages(request),
-      tools: this.buildTools(request),
-      temperature: request.temperature,
-      max_tokens: request.max_tokens,
-      response_format: request.json_mode ? { type: 'json_object' } : undefined,
-      stream: true as const,
-    }, { signal }) as unknown as AsyncIterable<ChatCompletionChunk>;
-
-    let textContent = '';
-    const toolCallMap = new Map<number, { id: string; name: string; args: string }>();
-    let finishReason = 'stop';
-
-    for await (const chunk of stream) {
-      if (signal?.aborted) throw new DOMException('Aborted', 'AbortError');
-      const delta = chunk.choices[0]?.delta;
-      if (delta?.content) {
-        textContent += delta.content;
-        onToken(delta.content);
-      }
-      if (delta?.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          if (!toolCallMap.has(tc.index)) {
-            toolCallMap.set(tc.index, { id: '', name: '', args: '' });
-          }
-          const acc = toolCallMap.get(tc.index)!;
-          if (tc.id) acc.id = tc.id;
-          if (tc.function?.name) acc.name += tc.function.name;
-          if (tc.function?.arguments) acc.args += tc.function.arguments;
-        }
-      }
-      if (chunk.choices[0]?.finish_reason) finishReason = chunk.choices[0].finish_reason;
-    }
-
-    const tool_calls = Array.from(toolCallMap.values()).map(tc => ({
-      id: tc.id,
-      name: tc.name,
-      arguments: JSON.parse(tc.args || '{}'),
-    }));
-
-    return { content: textContent, tool_calls, finish_reason: finishReason, usage: undefined };
-  }
-
-  private buildMessages(request: LLMRequest): ChatCompletionMessageParam[] {
-    return request.messages.map(msg => {
-      if (msg.role === 'system') return { role: 'system', content: msg.content };
-      if (msg.role === 'user') return { role: 'user', content: msg.content };
-      if (msg.role === 'assistant') return { role: 'assistant', content: msg.content };
-      throw new Error(`Unsupported message role: ${msg.role}`);
-    });
-  }
-
-  private buildTools(request: LLMRequest): ChatCompletionTool[] | undefined {
-    if (!request.tools || request.tools.length === 0) return undefined;
-    return request.tools.map(tool => ({
-      type: 'function' as const,
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.parameters,
-      },
-    }));
-  }
-}

package/src/providers/openai-responses.ts

@@ -1,212 +0,0 @@
-/**
- * OpenAI Responses API provider — supports models only available on /v1/responses
- * (e.g. gpt-5.1-codex-mini).
- *
- * Implements AgentLoopProvider to own the multi-turn tool-calling loop,
- * because the Responses API uses typed function_call / function_call_output
- * items that cannot be expressed as plain text messages.
- */
-
-import type { LLMRequest, LLMResponse, Message } from '@studio-foundation/contracts';
-import type { AgentLoopProvider, AgentLoopResult, ToolCallOutcome } from './provider.js';
-import OpenAI from 'openai';
-import type {
-  ResponseInputItem,
-  ResponseFunctionToolCall,
-  ResponseOutputItem,
-  FunctionTool,
-} from 'openai/resources/responses/responses.js';
-
-export class OpenAIResponsesProvider implements AgentLoopProvider {
-  readonly name = 'openai-responses';
-  private client: OpenAI;
-
-  constructor(apiKey?: string) {
-    this.client = new OpenAI({ apiKey: apiKey || process.env.OPENAI_API_KEY });
-  }
-
-  // Satisfy Provider interface for simple (no-tool) calls
-  async call(request: LLMRequest, _onToken?: (token: string) => void, signal?: AbortSignal): Promise<LLMResponse> {
-    const input = messagesToInput(request.messages);
-    const response = await this.client.responses.create({
-      model: request.model,
-      input,
-      temperature: request.temperature,
-      max_output_tokens: request.max_tokens ?? undefined,
-    }, { signal });
-
-    // NOTE: call() is for tool-free requests only.
-    // Tool calls in the response are intentionally discarded.
-    // For agentic tool-calling, use runAgentLoop() instead.
-    return {
-      content: response.output_text ?? '',
-      tool_calls: [],
-      finish_reason: 'stop',
-      usage: response.usage
-        ? {
-            prompt_tokens: response.usage.input_tokens,
-            completion_tokens: response.usage.output_tokens,
-            total_tokens: response.usage.total_tokens,
-          }
-        : undefined,
-    };
-  }
-
-  async runAgentLoop(
-    request: LLMRequest,
-    executeTool: (name: string, args: Record<string, unknown>, callId: string) => Promise<ToolCallOutcome>,
-    onToken?: (token: string) => void,
-    signal?: AbortSignal
-  ): Promise<AgentLoopResult> {
-    const tools: FunctionTool[] = (request.tools ?? []).map(t => ({
-      type: 'function' as const,
-      name: t.name,
-      description: t.description ?? null,
-      parameters: t.parameters as Record<string, unknown> | null,
-      strict: null,
-    }));
-
-    let input: ResponseInputItem[] = messagesToInput(request.messages);
-    const allToolCalls: AgentLoopResult['tool_calls'] = [];
-    const tokenAccumulator = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-    const MAX_ITERATIONS = 20;
-
-    for (let i = 0; i < MAX_ITERATIONS; i++) {
-      if (signal?.aborted) {
-        throw new DOMException('The operation was aborted', 'AbortError');
-      }
-
-      let outputItems: ResponseOutputItem[];
-      let responseText = '';
-
-      if (onToken) {
-        // Streaming path — emit text deltas as they arrive, then get the completed response
-        const stream = this.client.responses.stream({
-          model: request.model,
-          input,
-          tools: tools.length > 0 ? tools : undefined,
-          temperature: request.temperature,
-          max_output_tokens: request.max_tokens ?? undefined,
-        });
-
-        for await (const event of stream) {
-          if (event.type === 'response.output_text.delta') {
-            onToken(event.delta);
-            responseText += event.delta;
-          }
-        }
-
-        const finalResponse = await stream.finalResponse();
-
-        if (finalResponse.usage) {
-          tokenAccumulator.prompt_tokens += finalResponse.usage.input_tokens;
-          tokenAccumulator.completion_tokens += finalResponse.usage.output_tokens;
-          tokenAccumulator.total_tokens += finalResponse.usage.total_tokens;
-        }
-
-        outputItems = finalResponse.output;
-
-        // Find all function calls in the output
-        const functionCalls = outputItems.filter(
-          (item): item is ResponseFunctionToolCall => item.type === 'function_call'
-        );
-
-        if (functionCalls.length === 0) {
-          // No tool calls — done
-          return {
-            content: responseText,
-            tool_calls: allToolCalls,
-            finish_reason: 'stop',
-            usage: tokenAccumulator.total_tokens > 0 ? tokenAccumulator : undefined,
-          };
-        }
-
-        // Execute all tool calls
-        const toolOutputs: ResponseInputItem[] = [];
-        for (const fc of functionCalls) {
-          const args = JSON.parse(fc.arguments) as Record<string, unknown>;
-          const outcome = await executeTool(fc.name, args, fc.call_id);
-
-          allToolCalls.push({ id: fc.call_id, name: fc.name, arguments: args, ...outcome });
-
-          toolOutputs.push({
-            type: 'function_call_output',
-            call_id: fc.call_id,
-            output: outcome.error ? `Error: ${outcome.error}` : JSON.stringify(outcome.result),
-          } as ResponseInputItem.FunctionCallOutput);
-        }
-
-        // Extend input: previous input + this response's output items + tool results
-        // ResponseOutputItem is a subset of the ResponseInputItem union, so the cast is safe
-        input = [
-          ...input,
-          ...(outputItems as unknown as ResponseInputItem[]),
-          ...toolOutputs,
-        ];
-      } else {
-        // Non-streaming path
-        const response = await this.client.responses.create({
-          model: request.model,
-          input,
-          tools: tools.length > 0 ? tools : undefined,
-          temperature: request.temperature,
-          max_output_tokens: request.max_tokens ?? undefined,
-        }, { signal });
-
-        if (response.usage) {
-          tokenAccumulator.prompt_tokens += response.usage.input_tokens;
-          tokenAccumulator.completion_tokens += response.usage.output_tokens;
-          tokenAccumulator.total_tokens += response.usage.total_tokens;
-        }
-
-        // Find all function calls in the output
-        const functionCalls = response.output.filter(
-          (item): item is ResponseFunctionToolCall => item.type === 'function_call'
-        );
-
-        if (functionCalls.length === 0) {
-          // No tool calls — done
-          return {
-            content: response.output_text ?? '',
-            tool_calls: allToolCalls,
-            finish_reason: 'stop',
-            usage: tokenAccumulator.total_tokens > 0 ? tokenAccumulator : undefined,
-          };
-        }
-
-        // Execute all tool calls
-        const toolOutputs: ResponseInputItem[] = [];
-        for (const fc of functionCalls) {
-          const args = JSON.parse(fc.arguments) as Record<string, unknown>;
-          const outcome = await executeTool(fc.name, args, fc.call_id);
-
-          allToolCalls.push({ id: fc.call_id, name: fc.name, arguments: args, ...outcome });
-
-          toolOutputs.push({
-            type: 'function_call_output',
-            call_id: fc.call_id,
-            output: outcome.error ? `Error: ${outcome.error}` : JSON.stringify(outcome.result),
-          } as ResponseInputItem.FunctionCallOutput);
-        }
-
-        // Extend input: previous input + this response's output items + tool results
-        // ResponseOutputItem is a subset of the ResponseInputItem union, so the cast is safe
-        input = [
-          ...input,
-          ...(response.output as unknown as ResponseInputItem[]),
-          ...toolOutputs,
-        ];
-      }
-    }
-
-    throw new Error(`Maximum tool calling iterations (${MAX_ITERATIONS}) reached.`);
-  }
-}
-
-function messagesToInput(messages: Message[]): ResponseInputItem[] {
-  return messages.map(msg => ({
-    type: 'message' as const,
-    role: msg.role as 'user' | 'assistant' | 'system',
-    content: msg.content,
-  }));
-}

package/src/providers/openai.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { OpenAIProvider } from './openai.js';
-
-// Fake async iterable that yields chunks with a delay between each,
-// simulating a slow stream that should be interruptible.
-async function* slowStream(chunks: unknown[], delayMs = 10): AsyncGenerator<unknown> {
-  for (const chunk of chunks) {
-    await new Promise((r) => setTimeout(r, delayMs));
-    yield chunk;
-  }
-}
-
-vi.mock('openai', () => {
-  return {
-    default: class FakeOpenAI {
-      chat = {
-        completions: {
-          create: (_params: unknown, _opts: { signal?: AbortSignal }) =>
-            slowStream([
-              { choices: [{ delta: { content: 'hello' }, finish_reason: null }] },
-              { choices: [{ delta: { content: ' world' }, finish_reason: 'stop' }] },
-            ]),
-        },
-      };
-    },
-  };
-});
-
-describe('OpenAIProvider', () => {
-  it('aborts streaming when signal fires mid-iteration', async () => {
-    const provider = new OpenAIProvider('test-key');
-    const controller = new AbortController();
-    const onToken = vi.fn();
-
-    const callPromise = provider.call(
-      {
-        model: 'gpt-4o',
-        messages: [{ role: 'user', content: 'hi' }],
-      },
-      onToken,
-      controller.signal,
-    );
-
-    // Abort after first chunk has a chance to arrive
-    setTimeout(() => controller.abort(), 5);
-
-    await expect(callPromise).rejects.toSatisfy(
-      (e: unknown) => e instanceof DOMException && (e as DOMException).name === 'AbortError',
-    );
-  });
-
-  it('completes normally when signal is not aborted', async () => {
-    const provider = new OpenAIProvider('test-key');
-    const onToken = vi.fn();
-
-    const result = await provider.call(
-      {
-        model: 'gpt-4o',
-        messages: [{ role: 'user', content: 'hi' }],
-      },
-      onToken,
-    );
-
-    expect(result.content).toBe('hello world');
-    expect(onToken).toHaveBeenCalledTimes(2);
-  });
-});