import { registerProviderContract } from '../providers/provider-registry.js';
import { resolveOpenCodeExecutionPolicy, resolveOpenCodeInference } from '../providers/opencode-config.js';
import { mcpServersToOpenCodeConfig } from '../providers/mcp-to-opencode.js';
import type { ProviderRuntimeContract } from './registry.js';

export const opencodeRuntimeContract: ProviderRuntimeContract = {
  // This installed payload implements v1; a core upgrade must not opt it into a new seam.
  seamVersion: 1,
  configuration: {
    executionPolicy: { constant: resolveOpenCodeExecutionPolicy() },
    inference: resolveOpenCodeInference,
    memory: (hook) => ({ ...hook }),
    mcpServers: (servers) => mcpServersToOpenCodeConfig(servers),
  },
  textDelivery: 'result',
  commands: { formatting: 'xml' },
};
registerProviderContract('opencode', opencodeRuntimeContract);

import { describe, it, expect } from 'bun:test';

import { mcpServersToOpenCodeConfig } from './mcp-to-opencode.js';

describe('mcpServersToOpenCodeConfig', () => {
  it('maps nanoclaw + extra server like v2 index.ts merge', () => {
    const servers = {
      nanoclaw: {
        command: 'node',
        args: ['/app/src/mcp-tools/index.js'],
        env: {
          SESSION_INBOUND_DB_PATH: '/workspace/inbound.db',
          SESSION_OUTBOUND_DB_PATH: '/workspace/outbound.db',
          SESSION_HEARTBEAT_PATH: '/workspace/.heartbeat',
        },
      },
      extra: {
        command: 'npx',
        args: ['-y', 'some-mcp'],
        env: { FOO: 'bar' },
      },
    };

    const mcp = mcpServersToOpenCodeConfig(servers);

    expect(mcp.nanoclaw).toEqual({
      type: 'local',
      command: ['node', '/app/src/mcp-tools/index.js'],
      environment: {
        SESSION_INBOUND_DB_PATH: '/workspace/inbound.db',
        SESSION_OUTBOUND_DB_PATH: '/workspace/outbound.db',
        SESSION_HEARTBEAT_PATH: '/workspace/.heartbeat',
      },
      enabled: true,
    });

    expect(mcp.extra).toEqual({
      type: 'local',
      command: ['npx', '-y', 'some-mcp'],
      environment: { FOO: 'bar' },
      enabled: true,
    });
  });

  it('preserves local defaults when args and env are omitted', () => {
    const mcp = mcpServersToOpenCodeConfig({
      x: { command: 'true' },
    });
    expect(mcp.x).toEqual({
      type: 'local',
      command: ['true'],
      enabled: true,
    });
  });

  it('wraps a cwd-declaring server in the cd-then-exec argv', () => {
    const mcp = mcpServersToOpenCodeConfig({
      probe: { command: './run.js', args: ['--flag'], cwd: '/workspace/agent/plugin-data/sdr' },
    });
    expect(mcp.probe).toEqual({
      type: 'local',
      command: ['/bin/sh', '-c', 'cd "$0" && exec "$@"', '/workspace/agent/plugin-data/sdr', './run.js', '--flag'],
      enabled: true,
    });
  });

  it('maps Streamable HTTP servers to remote entries', () => {
    expect(
      mcpServersToOpenCodeConfig({
        docs: { type: 'http', url: 'https://mcp.example.com/mcp' },
      }).docs,
    ).toEqual({
      type: 'remote',
      url: 'https://mcp.example.com/mcp',
      enabled: true,
    });
  });

  it('passes remote headers through', () => {
    expect(
      mcpServersToOpenCodeConfig({
        docs: {
          type: 'http',
          url: 'https://mcp.example.com/mcp',
          headers: { 'X-Api-Version': '2024-06' },
        },
      }).docs,
    ).toEqual({
      type: 'remote',
      url: 'https://mcp.example.com/mcp',
      headers: { 'X-Api-Version': '2024-06' },
      enabled: true,
    });
  });

  it('returns empty record for undefined', () => {
    expect(mcpServersToOpenCodeConfig(undefined)).toEqual({});
  });
});

import { cwdWrappedArgv } from './cwd-shim.js';
import type { McpServerConfig } from './types.js';

/** OpenCode `mcp` entry shape (local stdio server). */
export type OpenCodeMcpLocal = {
  type: 'local';
  command: string[];
  environment?: Record<string, string>;
  enabled: true;
};

/** OpenCode `mcp` entry shape (remote HTTP server). */
export type OpenCodeMcpRemote = {
  type: 'remote';
  url: string;
  headers?: Record<string, string>;
  enabled: true;
};

export type OpenCodeMcpEntry = OpenCodeMcpLocal | OpenCodeMcpRemote;

/** Map NanoClaw MCP definitions into OpenCode's local/remote MCP config. */
export function mcpServersToOpenCodeConfig(
  servers: Record<string, McpServerConfig> | undefined,
): Record<string, OpenCodeMcpEntry> {
  const out: Record<string, OpenCodeMcpEntry> = {};
  if (!servers) return out;
  for (const [name, cfg] of Object.entries(servers)) {
    if (cfg.type === 'http') {
      out[name] = {
        type: 'remote',
        url: cfg.url,
        ...(cfg.headers && Object.keys(cfg.headers).length > 0 ? { headers: cfg.headers } : {}),
        enabled: true,
      };
      continue;
    }

    // OpenCode's local entry is a bare argv array with no spawn-directory
    // key, so a declared cwd goes through the shared cd-then-exec wrap —
    // never silently launched in the wrong directory.
    const args = cfg.args ?? [];
    const env = cfg.env ?? {};
    out[name] = {
      type: 'local',
      command: cfg.cwd ? cwdWrappedArgv(cfg.cwd, cfg.command, args) : [cfg.command, ...args],
      ...(Object.keys(env).length > 0 ? { environment: env } : {}),
      enabled: true,
    };
  }
  return out;
}

import { afterEach, describe, expect, it } from 'bun:test';
import fs from 'fs';
import os from 'os';
import path from 'path';
import { initializeOpenCodeAuth } from './opencode-auth.js';

const roots: string[] = [];
function root() {
  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'opencode-auth-'));
  roots.push(directory);
  return directory;
}
afterEach(() => {
  for (const directory of roots.splice(0)) fs.rmSync(directory, { recursive: true, force: true });
});

describe('container-owned OpenCode auth state', () => {
  it('creates fresh OAuth placeholders and resets stale state before a restart', () => {
    const directory = root();
    const auth = path.join(directory, 'opencode/auth.json');
    initializeOpenCodeAuth(directory, 'chatgpt');
    const expected = {
      openai: {
        type: 'oauth',
        access: 'nc-opencode-token-v1',
        refresh: 'nc-opencode-token-v1',
        accountId: 'nc-opencode-token-v1',
        expires: Date.UTC(2100, 0, 1),
      },
    };
    expect(JSON.parse(fs.readFileSync(auth, 'utf8'))).toEqual(expected);
    fs.writeFileSync(auth, '{corrupt or stale');
    initializeOpenCodeAuth(directory, 'chatgpt');
    expect(JSON.parse(fs.readFileSync(auth, 'utf8'))).toEqual(expected);
    expect(fs.statSync(auth).mode & 0o777).toBe(0o600);
    expect(fs.readdirSync(path.dirname(auth))).toEqual(['auth.json']);
  });

  it('clears OAuth on switching to API-key mode and restores it on switching back', () => {
    const directory = root();
    const auth = path.join(directory, 'opencode/auth.json');
    initializeOpenCodeAuth(directory, 'chatgpt');
    initializeOpenCodeAuth(directory, 'api-key');
    expect(JSON.parse(fs.readFileSync(auth, 'utf8'))).toEqual({});
    initializeOpenCodeAuth(directory, 'chatgpt');
    expect(JSON.parse(fs.readFileSync(auth, 'utf8')).openai.type).toBe('oauth');
  });

  it('replaces planted file links without overwriting their targets', () => {
    const directory = root();
    const unrelated = path.join(directory, 'unrelated');
    fs.writeFileSync(unrelated, 'preserve');
    fs.mkdirSync(path.join(directory, 'opencode'));
    const auth = path.join(directory, 'opencode/auth.json');
    fs.symlinkSync(unrelated, auth);
    initializeOpenCodeAuth(directory, 'chatgpt');
    expect(fs.lstatSync(auth).isFile()).toBe(true);
    expect(fs.readFileSync(unrelated, 'utf8')).toBe('preserve');
  });

  it('rejects a symlinked auth directory without writing through it', () => {
    const directory = root();
    const target = root();
    fs.symlinkSync(target, path.join(directory, 'opencode'));
    expect(() => initializeOpenCodeAuth(directory, 'chatgpt')).toThrow('not symlinks');
    expect(fs.readdirSync(target)).toEqual([]);
  });
  it('rejects a linked data root before creating an auth directory in its target', () => {
    const directory = root();
    const target = root();
    const linked = path.join(directory, 'data');
    fs.symlinkSync(target, linked);
    expect(() => initializeOpenCodeAuth(linked, 'chatgpt')).toThrow('not symlinks');
    expect(fs.readdirSync(target)).toEqual([]);
  });
});

import { randomUUID } from 'crypto';
import fs from 'fs';
import path from 'path';

export const OPENCODE_CREDENTIAL_PLACEHOLDER = 'nc-opencode-token-v1';

/** Initialize this container's private auth state before every server start.
 * These placeholders select OpenCode's OAuth transport; the selected gateway owns real tokens.
 * API-key mode clears stale OAuth state when a session changes backend.
 */
export function initializeOpenCodeAuth(dataHome: string, mode: string | undefined): void {
  if (!path.isAbsolute(dataHome)) throw new Error('OpenCode requires an absolute XDG_DATA_HOME');
  const directory = path.join(dataHome, 'opencode');
  fs.mkdirSync(dataHome, { recursive: true, mode: 0o700 });
  if (!fs.lstatSync(dataHome).isDirectory()) throw new Error('OpenCode auth state must use directories, not symlinks');
  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
  if (!fs.lstatSync(directory).isDirectory()) {
    throw new Error('OpenCode auth state must use directories, not symlinks');
  }
  const auth =
    mode === 'chatgpt'
      ? {
          openai: {
            type: 'oauth',
            access: OPENCODE_CREDENTIAL_PLACEHOLDER,
            refresh: OPENCODE_CREDENTIAL_PLACEHOLDER,
            accountId: OPENCODE_CREDENTIAL_PLACEHOLDER,
            expires: Date.UTC(2100, 0, 1),
          },
        }
      : {};
  const temporary = path.join(directory, `.auth-${randomUUID()}.tmp`);
  try {
    fs.writeFileSync(temporary, `${JSON.stringify(auth)}\n`, { mode: 0o600, flag: 'wx' });
    // Replace stale files or symlinks without following or changing their targets.
    fs.renameSync(temporary, path.join(directory, 'auth.json'));
  } finally {
    fs.rmSync(temporary, { force: true });
  }
}

import type { ProviderOptions } from './types.js';
import type { ResolvedRuntimeConfiguration, RuntimeInferenceInput } from '../provider-contracts/registry.js';
import { mcpServersToOpenCodeConfig } from './mcp-to-opencode.js';
import { openCodeInstructionsPath } from './opencode-memory.js';
import { OPENCODE_CREDENTIAL_PLACEHOLDER } from './opencode-auth.js';
const MODEL_INPUT_MODALITIES = ['text', 'audio', 'image', 'video', 'pdf'] as const;
const AGENT_DIR = '/workspace/agent';

export function buildOpenCodeServerEnv(
  config: Record<string, unknown>,
  environment: NodeJS.ProcessEnv = process.env,
): NodeJS.ProcessEnv {
  return {
    ...environment,
    OPENCODE_DISABLE_PROJECT_CONFIG: 'true',
    OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
  };
}
function log(message: string): void {
  console.error(`[opencode-provider] ${message}`);
}

// A limit env var must be a bare positive integer (a token count) — units
// ("64k"), blank strings, zero, and negatives are rejected rather than
// coerced: Number() would turn blank into 0 (silently disables compaction,
// see below) and "64k" into NaN (the emitted config becomes unparseable
// JSON, and OpenCode fails to start). Invalid input is treated as unset.
function parseLimitEnv(varName: string, raw: string | undefined): number | undefined {
  if (raw === undefined) return undefined;
  const trimmed = raw.trim();
  if (!/^\d+$/.test(trimmed) || !Number.isSafeInteger(Number(trimmed)) || Number(trimmed) <= 0) {
    log(`Ignoring invalid ${varName}: "${raw}"`);
    return undefined;
  }
  return Number(trimmed);
}

export function resolveOpenCodeInference(
  input: RuntimeInferenceInput,
  environment: NodeJS.ProcessEnv,
): Record<string, unknown> {
  const provider = environment.OPENCODE_PROVIDER || 'anthropic';
  const model = input.model ?? environment.OPENCODE_MODEL;
  const smallModel = environment.OPENCODE_SMALL_MODEL;
  // Reasoning effort from the group's container config (ncl groups config
  // update --effort). OpenCode forwards a free-form per-model `options` object
  // to the ai-sdk provider, which maps reasoningEffort onto reasoning_effort in
  // the request body.
  const effort = input.effort;
  // New installs own their endpoint setting. The explicit native value
  // suppresses the historical shared-variable fallback without editing it.
  const endpoint = environment.OPENCODE_BASE_URL ?? environment.ANTHROPIC_BASE_URL;
  const proxyUrl = endpoint === 'native' ? undefined : endpoint;

  const stripProviderPrefix = (value: string | undefined) =>
    value?.startsWith(`${provider}/`) ? value.slice(provider.length + 1) : value;
  const providerModelId = stripProviderPrefix(model);
  const providerSmallModelId = stripProviderPrefix(smallModel);
  const modelsToRegister = [providerModelId, providerSmallModelId]
    .filter(Boolean)
    .filter((mid, i, a) => a.indexOf(mid as string) === i);

  // OpenCode auto-compacts a session once tokens >= limit.context - maxOutputTokens.
  // Undeclared custom models resolve limit.context to 0, which silently disables
  // compaction and kills long sessions against a fixed-window backend (e.g. vLLM).
  // Absent these env vars, behavior is unchanged (no `limit` key emitted).
  const contextLimitEnv = environment.OPENCODE_MODEL_CONTEXT_LIMIT;
  const outputLimitEnv = environment.OPENCODE_MODEL_OUTPUT_LIMIT;
  const contextLimit = parseLimitEnv('OPENCODE_MODEL_CONTEXT_LIMIT', contextLimitEnv);
  const outputLimit = parseLimitEnv('OPENCODE_MODEL_OUTPUT_LIMIT', outputLimitEnv);
  if (outputLimitEnv !== undefined && contextLimit === undefined) {
    log('Ignoring OPENCODE_MODEL_OUTPUT_LIMIT: no valid OPENCODE_MODEL_CONTEXT_LIMIT to pair it with');
  }
  const modelLimit =
    contextLimit !== undefined
      ? { context: contextLimit, ...(outputLimit !== undefined ? { output: outputLimit } : {}) }
      : undefined;

  // OpenCode drops every non-text file part whose modality the model does not
  // declare: the provider transform keeps a part only when the model advertises
  // that input modality, and otherwise substitutes
  // `ERROR: Cannot read … (this model does not support <modality> input)`.
  // A registry-unknown custom model resolves each of those flags to false
  // (provider/provider.ts:1154-1158), so an image reaches the session store but
  // never the model — live-confirmed on a vLLM-hosted model, which answered
  // that it does not support image input while the prompt carried zero image
  // tokens. Declaring the modalities is the only thing that opens that gate;
  // `attachment` is a registry/UI flag rather than a pipeline gate, but it is
  // set alongside so the entry stays internally consistent.
  // Absent this env var, behavior is unchanged (no capability keys emitted).
  const modalityEnv = environment.OPENCODE_MODEL_INPUT_MODALITIES;
  const requestedModalities = (modalityEnv ?? '')
    .split(',')
    .map((entry) => entry.trim().toLowerCase())
    .filter(Boolean)
    .filter((entry, i, a) => a.indexOf(entry) === i)
    .filter((entry) => {
      if ((MODEL_INPUT_MODALITIES as readonly string[]).includes(entry)) return true;
      log(`Ignoring unknown OPENCODE_MODEL_INPUT_MODALITIES entry: ${entry}`);
      return false;
    })
    .filter((entry) => entry !== 'text');
  const modelModalities =
    requestedModalities.length > 0 ? { input: ['text', ...requestedModalities], output: ['text'] } : undefined;

  // Native API providers also need a placeholder to become connected before
  // any HTTP request reaches the selected gateway. Model options do not depend on baseURL.
  const providerOptions: Record<string, unknown> = {
    [provider]: {
      // A custom base URL on the `openai` provider means a self-hosted
      // OpenAI-compatible endpoint (vLLM, llama.cpp, …). The stock openai
      // SDK package speaks the Responses API, whose multi-turn history
      // vLLM rejects (assistant items lack id/status) — pin the Chat
      // Completions transport. Scoped to `openai` only: other providers
      // (e.g. `openrouter`, set alongside ANTHROPIC_BASE_URL per the
      // documented OpenRouter config) ship their own native ai-sdk
      // package and must keep OpenCode's default transport resolution.
      ...(provider === 'openai' && proxyUrl ? { npm: '@ai-sdk/openai-compatible' } : {}),
      options: { apiKey: OPENCODE_CREDENTIAL_PLACEHOLDER, ...(proxyUrl ? { baseURL: proxyUrl } : {}) },
      ...(modelsToRegister.length > 0
        ? {
            models: Object.fromEntries(
              modelsToRegister.map((mid) => {
                // limit/modalities describe the MAIN model only — the env
                // vars name no small-model equivalent. Spreading them onto
                // a distinct OPENCODE_SMALL_MODEL entry would falsely
                // declare its context window and media support as the
                // main model's own. A small model that differs from the
                // main one gets a bare entry instead, which resolves
                // through OpenCode's own undeclared-model default.
                const isMainModel = mid === providerModelId;
                return [
                  mid,
                  {
                    id: mid,
                    name: mid,
                    tool_call: true,
                    ...(isMainModel && effort ? { options: { reasoningEffort: effort } } : {}),
                    ...(isMainModel && modelLimit ? { limit: modelLimit } : {}),
                    ...(isMainModel && modelModalities ? { attachment: true, modalities: modelModalities } : {}),
                  },
                ];
              }),
            ),
          }
        : {}),
    },
  };

  return {
    ...(model ? { model } : {}),
    ...(smallModel ? { small_model: smallModel } : {}),
    enabled_providers: [provider],
    provider: providerOptions,
  };
}

/**
 * The configured `provider/model` as the prompt API names it. OpenCode stores
 * the model a session was created with and reuses it on resume, so a group
 * whose backend or model changed would keep prompting the old one and fail
 * with "Model not found"; naming the model on every prompt makes the current
 * configuration apply to the next turn. Undefined leaves OpenCode's default.
 */
export function resolveOpenCodePromptModel(
  inference: Record<string, unknown>,
): { providerID: string; modelID: string } | undefined {
  const model = inference.model;
  if (typeof model !== 'string') return undefined;
  const slash = model.indexOf('/');
  if (slash <= 0 || slash === model.length - 1) return undefined;
  return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
}

// OpenCode's interactive question tool cannot wait for an answer in a headless runner.
export function resolveOpenCodeExecutionPolicy(): Record<string, unknown> {
  return {
    read: 'allow',
    edit: 'allow',
    glob: 'allow',
    grep: 'allow',
    list: 'allow',
    bash: 'allow',
    task: 'allow',
    external_directory: 'allow',
    todowrite: 'allow',
    question: 'deny',
    webfetch: 'allow',
    websearch: 'allow',
    codesearch: 'allow',
    lsp: 'allow',
    doom_loop: 'allow',
    skill: 'allow',
  };
}

export function buildOpenCodeConfig(
  options: ProviderOptions,
  configuration?: ResolvedRuntimeConfiguration,
): Record<string, unknown> {
  const inference = (configuration?.inference ?? resolveOpenCodeInference(options, process.env)) as Record<
    string,
    unknown
  >;
  return {
    ...inference,
    permission: configuration ? configuration.executionPolicy : resolveOpenCodeExecutionPolicy(),
    mcp: configuration ? configuration.mcpServers : mcpServersToOpenCodeConfig(options.mcpServers),
    autoupdate: false,
    snapshot: false,
    // Core's human-question tool waits up to five minutes. This request budget
    // leaves room for delivery/polling; MCP connection startup keeps its own limit.
    experimental: { mcp_timeout: 330_000 },
    // The runner renders this file once per turn. Native steps, compaction
    // continuation and Task children reread it through the instructions pipeline.
    instructions: [`${AGENT_DIR}/CLAUDE.md`, `${AGENT_DIR}/CLAUDE.local.md`, openCodeInstructionsPath()],
  };
}

import { spawnSync } from 'child_process';
import { mkdirSync, renameSync, writeFileSync } from 'fs';
import { homedir } from 'os';
import path from 'path';
import { randomUUID } from 'crypto';

function log(message: string): void {
  console.error(`[opencode-memory] ${message}`);
}

export function openCodeInstructionsPath(): string {
  return path.resolve(process.env.XDG_DATA_HOME || path.join(homedir(), '.local', 'share'), 'nanoclaw-instructions.md');
}

/** Refresh under the turn lock. Native steps and Task children reread this file. */
export function prepareOpenCodeMemory(
  hook: OpenCodeMemorySessionHook,
  instructions: string | undefined,
  reminder: string,
  file = openCodeInstructionsPath(),
): void {
  const content = [runMemorySessionHook(hook, 'startup'), instructions, reminder].filter(Boolean).join('\n\n');
  mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
  const temporary = `${file}.${randomUUID()}.tmp`;
  writeFileSync(temporary, content, { mode: 0o600, flag: 'wx' });
  renameSync(temporary, file);
}

export interface OpenCodeMemorySessionHook {
  readonly command: string;
  readonly legacyCommands: readonly string[];
  readonly sources: readonly string[];
}

/** Sources understood by the shared renderer; turn preparation uses startup. */
export type OpenCodeMemorySource = 'startup' | 'compact';

/** Matches the `timeout: 10` (seconds) the Claude provider registers for the same command. */
const MEMORY_HOOK_TIMEOUT_MS = 10_000;

/** Run the registered renderer without duplicating its memory caps. Failures
 * log and return undefined; successful empty output remains distinguishable.
 */
export function runMemorySessionHook(
  hook: OpenCodeMemorySessionHook | undefined,
  source: OpenCodeMemorySource,
): string | undefined {
  if (!hook) {
    log(`No memory session hook registered; skipping ${source} memory injection`);
    return undefined;
  }
  if (!hook.sources.includes(source)) {
    log(`Memory session hook does not declare source ${source}; skipping injection`);
    return undefined;
  }

  try {
    const res = spawnSync(hook.command, {
      shell: true,
      input: JSON.stringify({ hook_event_name: 'SessionStart', source }),
      encoding: 'utf-8',
      timeout: MEMORY_HOOK_TIMEOUT_MS,
    });
    if (res.error || res.status !== 0) {
      const why = res.error ? res.error.message : `exit ${String(res.status)}`;
      log(`Memory session hook (${source}) failed (${why}); continuing without memory`);
      return undefined;
    }
    const out = (res.stdout ?? '').trim();
    if (!out) {
      log(`Memory session hook (${source}) produced no output; continuing without memory`);
      return '';
    }
    return out;
  } catch (err) {
    log(`Memory session hook (${source}) failed: ${err instanceof Error ? err.message : String(err)}`);
    return undefined;
  }
}

import { describe, it, expect } from 'bun:test';
import './index.js';
import '../provider-contracts/index.js';
import { getProviderRuntimeContract, listProviderNames } from './provider-registry.js';

// `bun test --isolate` keeps sibling tests' direct provider imports out of this registry.
describe('opencode provider registration', () => {
  it('declares the runtime seam implemented by this installed payload', () => {
    expect(getProviderRuntimeContract('opencode')?.seamVersion).toBe(1);
  });
  it('registers opencode via the provider barrel', () => {
    expect(listProviderNames()).toContain('opencode');
  });
});

import { randomBytes } from 'crypto';

export interface OpenCodeEvent {
  type: string;
  properties: Record<string, unknown>;
}

export interface OpenCodeMessage {
  info: {
    id: string;
    role: string;
    parentID?: string;
    summary?: boolean;
    error?: unknown;
    time: { created: number; completed?: number };
  };
  parts: Array<{ id: string; type: string; text?: string; ignored?: boolean }>;
}

export interface OpenCodeTurnResult {
  text: string | null;
  isError?: boolean;
}

/** The configured model as OpenCode's prompt API names it. */
export interface OpenCodePromptModel {
  providerID: string;
  modelID: string;
}

export interface OpenCodeSessionClient {
  create(params?: { signal?: AbortSignal }): Promise<{ data?: { id?: string }; error?: unknown }>;
  prompt(params: {
    path: { id: string };
    body: { messageID: string; parts: unknown[]; model?: OpenCodePromptModel };
    signal?: AbortSignal;
  }): Promise<{ data?: OpenCodeMessage; error?: unknown }>;
  messages(params: {
    path: { id: string };
    query: { limit: number };
    signal?: AbortSignal;
  }): Promise<{ data?: OpenCodeMessage[]; error?: unknown }>;
  abort(params: { path: { id: string }; signal?: AbortSignal }): Promise<{ error?: unknown }>;
}

/** One eager reader per runtime; no parked per-turn iterator can eat a later event. */
export class OpenCodeEventPump {
  readonly ready: Promise<void>;
  lastEventAt = Date.now();
  failure?: Error;
  private listeners = new Set<(event?: OpenCodeEvent) => void>();
  private parents = new Map<string, string | undefined>();

  constructor(stream: AsyncGenerator<OpenCodeEvent, void, void>, onEvent: (event: OpenCodeEvent) => void) {
    let connected!: () => void;
    let reject!: (error: Error) => void;
    this.ready = new Promise<void>((resolve, fail) => {
      connected = resolve;
      reject = fail;
    });
    // Initialization may fail before a caller reaches ready. Keep the rejection observed.
    void this.ready.catch(() => {});
    void (async () => {
      try {
        for await (const event of stream) {
          this.lastEventAt = Date.now();
          if (event.type === 'server.connected') connected();
          if (event.type === 'session.created' || event.type === 'session.updated') {
            const info = event.properties.info as { id?: string; parentID?: string } | undefined;
            if (info?.id) this.parents.set(info.id, info.parentID);
          }
          onEvent(event);
          for (const listener of this.listeners) listener(event);
        }
        throw new Error('OpenCode event stream ended unexpectedly');
      } catch (error) {
        this.failure = new Error(
          `OpenCode event stream failed: ${error instanceof Error ? error.message : String(error)}`,
        );
        reject(this.failure);
        for (const listener of this.listeners) listener();
      }
    })();
  }

  listen(listener: (event?: OpenCodeEvent) => void): () => void {
    this.listeners.add(listener);
    return () => this.listeners.delete(listener);
  }

  belongsTo(sessionId: string | undefined, ancestor: string): boolean {
    for (let depth = 0; sessionId && depth < 32; depth++) {
      if (sessionId === ancestor) return true;
      sessionId = this.parents.get(sessionId);
    }
    return false;
  }
}

const turns = new WeakMap<object, Promise<void>>();

/** The native server joins concurrent calls to one run; queue them here instead. */
export async function acquireOpenCodeTurn(runtime: object, signal: AbortSignal): Promise<() => void> {
  const previous = turns.get(runtime) ?? Promise.resolve();
  let release!: () => void;
  const current = new Promise<void>((resolve) => {
    release = resolve;
  });
  const tail = previous.then(() => current);
  turns.set(runtime, tail);
  let cancel!: () => void;
  const cancelled = new Promise<never>((_, reject) => {
    cancel = () => reject(new Error('OpenCode query aborted'));
    signal.addEventListener('abort', cancel, { once: true });
    if (signal.aborted) cancel();
  });
  try {
    await Promise.race([previous, cancelled]);
  } catch (error) {
    release();
    throw error;
  } finally {
    signal.removeEventListener('abort', cancel);
  }
  return release;
}

let messageCounter = 0;
export function createOpenCodeMessageId(): string {
  const time = (BigInt(Date.now()) * 4096n + BigInt(messageCounter++ % 4096)) & ((1n << 48n) - 1n);
  // OpenCode's native IDs use a 12-hex time/counter prefix and 14 base62 characters.
  const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
  const suffix = Array.from(randomBytes(14), (byte) => alphabet[byte % alphabet.length]).join('');
  return `msg_${time.toString(16).padStart(12, '0')}${suffix}`;
}

export function openCodeError(error: unknown): Error {
  return new Error(`OpenCode prompt failed: ${JSON.stringify(error)}`);
}

export async function boundedOpenCodeCall<T>(
  call: (signal: AbortSignal) => Promise<T>,
  signal?: AbortSignal,
  timeout = 10_000,
): Promise<T> {
  const controller = new AbortController();
  const forward = () => controller.abort(signal?.reason);
  signal?.addEventListener('abort', forward, { once: true });
  if (signal?.aborted) forward();
  const timer = setTimeout(() => controller.abort(new Error('OpenCode control request timed out')), timeout);
  let reject!: (error: Error) => void;
  const cancelled = new Promise<never>((_, fail) => {
    reject = fail;
  });
  const cancel = () => reject(controller.signal.reason ?? new Error('OpenCode query aborted'));
  controller.signal.addEventListener('abort', cancel, { once: true });
  if (controller.signal.aborted) cancel();
  try {
    return await Promise.race([call(controller.signal), cancelled]);
  } finally {
    clearTimeout(timer);
    signal?.removeEventListener('abort', forward);
    controller.signal.removeEventListener('abort', cancel);
  }
}

export async function* executeOpenCodeTurn(options: {
  runtime: object;
  client: OpenCodeSessionClient;
  pump: OpenCodeEventPump;
  sessionId: string;
  parts: unknown[];
  /** Sent with every prompt: a resumed session otherwise keeps the model it was created with. */
  model?: OpenCodePromptModel;
  signal: AbortSignal;
  silenceMs: number;
  idleMs: number;
  prepare?(): void;
  discard(): void;
}): AsyncGenerator<{ type: 'activity' } | { type: 'error'; message: string; retryable: false }, OpenCodeTurnResult> {
  const { client, pump, sessionId, signal } = options;
  const release = await acquireOpenCodeTurn(options.runtime, signal);
  const request = new AbortController();
  let started = false;
  let promptRequest: ReturnType<OpenCodeSessionClient['prompt']> | undefined;
  let completedResponse = false;
  let streamSilent = false;
  let failure: Error | undefined;
  let activity = false;
  let lastActivityAt = Date.now();
  let wake: (() => void) | undefined;
  const fail = (error: Error) => {
    failure ??= error;
    wake?.();
  };
  const cancelled = () => fail(new Error('OpenCode query aborted'));
  signal.addEventListener('abort', cancelled, { once: true });
  const unlisten = pump.listen((event) => {
    if (!event) return fail(pump.failure!);
    const properties = event.properties;
    const record = (properties.info ?? properties.part ?? properties) as { sessionID?: string };
    if (!pump.belongsTo(record.sessionID, sessionId)) return;
    // Error/idle events can belong to an earlier run or recoverable compaction.
    // Native execution also owns retry policy; retry status is activity, not
    // an independent limit that can cut off a recoverable native request.
    // Only the synchronous response determines whether this turn succeeded.
    if (event.type === 'session.idle' || event.type === 'session.error') return;
    activity = true;
    lastActivityAt = Date.now();
    wake?.();
  });
  const timer = setInterval(
    () => {
      if (Date.now() - pump.lastEventAt >= options.silenceMs) {
        streamSilent = true;
        fail(new Error(`OpenCode event stream silent for ${options.silenceMs}ms; server dropped`));
      } else if (Date.now() - lastActivityAt >= options.idleMs) {
        fail(new Error(`OpenCode turn produced no activity for ${options.idleMs}ms; aborted`));
      }
    },
    Math.min(5000, options.silenceMs, options.idleMs),
  );
  try {
    if (signal.aborted) cancelled();
    await boundedOpenCodeCall(() => pump.ready, signal);
    if (pump.failure) throw pump.failure;
    const prior = await boundedOpenCodeCall(
      (signal) => client.messages({ path: { id: sessionId }, query: { limit: 100 }, signal }),
      signal,
    );
    if (prior.error) throw openCodeError(prior.error);
    if (failure) throw failure;
    options.prepare?.();
    const messageId = createOpenCodeMessageId();
    let response: Awaited<ReturnType<OpenCodeSessionClient['prompt']>> | undefined;
    let finished = false;
    started = true;
    promptRequest = client.prompt({
      path: { id: sessionId },
      body: { messageID: messageId, parts: options.parts, ...(options.model ? { model: options.model } : {}) },
      signal: request.signal,
    });
    void promptRequest.then(
      (value) => {
        response = value;
        finished = true;
        completedResponse = true;
        wake?.();
      },
      (error) => {
        fail(error instanceof Error ? error : new Error(String(error)));
      },
    );
    while (!finished && !failure) {
      if (activity) {
        activity = false;
        yield { type: 'activity' };
        continue;
      }
      await new Promise<void>((resolve) => {
        wake = resolve;
      });
      wake = undefined;
    }
    if (failure) throw failure;
    if (response?.error) throw openCodeError(response.error);
    if (!response?.data) throw new Error('OpenCode prompt returned no completed assistant');
    const text = await reconcileOpenCodeTurn(
      client,
      sessionId,
      messageId,
      response.data,
      new Set((prior.data ?? []).map((m) => m.info.id)),
      signal,
    );
    if (response.data.info.error) {
      const message = openCodeError(response.data.info.error).message;
      yield { type: 'error', message, retryable: false };
      // One final result preserves completed earlier steps without duplicate
      // exchange callbacks or an automatic retry of the failed turn. Diagnostics
      // stay in the error event for logs: response bodies may contain message
      // markup that must never be interpreted as a model-authored deliverable.
      // Core supplies a fixed failure notice even when no model text survived.
      return { text, isError: true };
    }
    return { text };
  } finally {
    clearInterval(timer);
    unlisten();
    signal.removeEventListener('abort', cancelled);
    // HTTP disconnect only cancels its waiter. Stop native execution explicitly,
    // then release the serialization lock. If cleanup cannot be confirmed, kill
    // the owned runtime so a later prompt cannot join an abandoned native run.
    if (started && !completedResponse) {
      try {
        const result = await boundedOpenCodeCall((signal) => client.abort({ path: { id: sessionId }, signal }));
        if (result.error) throw openCodeError(result.error);
        // An abort can arrive before prompt registration. The original HTTP
        // completion must also settle; an abort acknowledgement alone proves
        // nothing about that race. A lost response forces runtime teardown.
        if (!completedResponse && promptRequest) await boundedOpenCodeCall(() => promptRequest!);
      } catch {
        options.discard();
      }
    }
    if (pump.failure || streamSilent) options.discard();
    request.abort();
    release();
  }
}

/** Read enough of the durable suffix to prove which prompt the response belongs to. */
export async function reconcileOpenCodeTurn(
  client: OpenCodeSessionClient,
  sessionId: string,
  messageId: string,
  result: OpenCodeMessage,
  priorIds: ReadonlySet<string>,
  signal: AbortSignal,
): Promise<string | null> {
  let messages: OpenCodeMessage[] = [];
  let marker: OpenCodeMessage | undefined;
  for (let limit = 100; limit <= 6400; limit *= 2) {
    // Each request has its own bound. A long but healthy history can require
    // several reads; one shared deadline would discard an already completed
    // reply even when every individual request responds promptly.
    const response = await boundedOpenCodeCall(
      (signal) => client.messages({ path: { id: sessionId }, query: { limit }, signal }),
      signal,
    );
    if (response.error) throw openCodeError(response.error);
    messages = response.data ?? [];
    marker = messages.find((message) => message.info.id === messageId && message.info.role === 'user');
    if (marker) break;
    if (messages.length < limit) break;
  }
  if (!marker) throw new Error('OpenCode completed without a verifiable prompt in session history; refusing to replay');

  // Compaction creates replay/auto-continue user messages. Include those descendants,
  // even when an independent native ID counter puts them before our marker in a tie.
  const users = new Set(
    messages
      .filter(
        (message) =>
          message.info.role === 'user' &&
          message.info.time.created >= marker!.info.time.created &&
          !priorIds.has(message.info.id),
      )
      .map((message) => message.info.id),
  );
  users.add(messageId);
  const assistants = messages.filter(
    (message) => message.info.role === 'assistant' && message.info.parentID && users.has(message.info.parentID),
  );
  if (!assistants.some((message) => message.info.id === result.info.id)) {
    throw new Error('OpenCode returned an assistant from another turn; refusing to replay');
  }
  const parts = new Set<string>();
  const text: string[] = [];
  for (const message of assistants) {
    // A recovered overflow record is not the outcome, and a summary is internal context.
    if (message.info.summary || message.info.error) continue;
    if (result.info.error && message.info.time.completed === undefined) continue;
    for (const part of message.parts) {
      if (part.type !== 'text' || part.ignored || !part.text || parts.has(part.id)) continue;
      parts.add(part.id);
      text.push(part.text);
    }
  }
  return text.join('\n\n') || null;
}

import { afterEach, describe, expect, it } from 'bun:test';

import {
  buildAttachmentFileParts,
  buildPromptParts,
  resolveNativeAttachmentLimits,
  type NativeAttachmentFileInfo,
  type NativeAttachmentLimits,
} from './opencode.js';

const PRESENT = new Map<string, number>([
  ['/workspace/inbox/msg-1/cat.png', 1_024],
  ['/workspace/inbox/msg-1/report.pdf', 2_048],
  ['/workspace/inbox/msg-1/blob', 128],
  ['/workspace/inbox/msg-1/second.png', 3_072],
]);
const inspect = (filePath: string): NativeAttachmentFileInfo | null => {
  const size = PRESENT.get(filePath);
  return size === undefined ? null : { realPath: filePath, size };
};
const generous: NativeAttachmentLimits = { maxCount: 8, maxBytes: 25 * 1024 * 1024 };

function attachment(filename: string, mime: string | undefined, sourceMessageId = 'msg-1') {
  return {
    sourceMessageId,
    filename,
    ...(mime ? { mime } : {}),
    path: `/workspace/inbox/${sourceMessageId}/${filename}`,
  };
}

afterEach(() => {
  delete process.env.OPENCODE_NATIVE_ATTACHMENT_MAX_COUNT;
  delete process.env.OPENCODE_NATIVE_ATTACHMENT_MAX_BYTES;
});

describe('buildAttachmentFileParts', () => {
  it('sends a message-bound image as a file part', () => {
    expect(buildAttachmentFileParts([attachment('cat.png', 'image/png')], inspect, generous)).toEqual([
      {
        type: 'file',
        mime: 'image/png',
        filename: 'msg-1--cat.png',
        url: 'file:///workspace/inbox/msg-1/cat.png',
      },
    ]);
  });

  it('sends a PDF and falls back to a recognized extension', () => {
    const parts = buildAttachmentFileParts(
      [attachment('report.pdf', 'application/pdf'), attachment('cat.png', undefined)],
      inspect,
      generous,
    );
    expect(parts.map((part) => part.mime)).toEqual(['application/pdf', 'image/png']);
  });

  it('rejects a path outside the source message inbox even when it exists', () => {
    const forged = {
      sourceMessageId: 'msg-1',
      filename: 'cat.png',
      mime: 'image/png',
      path: '/workspace/agent/cat.png',
    };
    const forgedInspect = (): NativeAttachmentFileInfo => ({ realPath: '/workspace/agent/cat.png', size: 10 });
    expect(buildAttachmentFileParts([forged], forgedInspect, generous)).toEqual([]);
  });

  it('rejects a symlink/escape reported by filesystem inspection', () => {
    const escapedInspect = (): NativeAttachmentFileInfo => ({ realPath: '/workspace/agent/private.pdf', size: 10 });
    expect(buildAttachmentFileParts([attachment('report.pdf', 'application/pdf')], escapedInspect, generous)).toEqual(
      [],
    );
  });

  it('skips missing and non-media files', () => {
    expect(
      buildAttachmentFileParts(
        [
          attachment('gone.png', 'image/png', 'msg-9'),
          attachment('cat.png', 'text/plain'),
          attachment('blob', undefined),
        ],
        inspect,
        generous,
      ),
    ).toEqual([]);
  });

  it('enforces count and actual total-byte limits', () => {
    const files = [attachment('cat.png', 'image/png'), attachment('second.png', 'image/png')];
    expect(buildAttachmentFileParts(files, inspect, { maxCount: 1, maxBytes: 10_000 })).toHaveLength(1);
    expect(buildAttachmentFileParts(files, inspect, { maxCount: 8, maxBytes: 3_000 })).toHaveLength(1);
    expect(buildAttachmentFileParts(files, inspect, { maxCount: 8, maxBytes: 500 })).toEqual([]);
  });

  it('uses safe defaults and accepts positive environment overrides', () => {
    expect(resolveNativeAttachmentLimits()).toEqual({ maxCount: 8, maxBytes: 25 * 1024 * 1024 });
    process.env.OPENCODE_NATIVE_ATTACHMENT_MAX_COUNT = '3';
    process.env.OPENCODE_NATIVE_ATTACHMENT_MAX_BYTES = '4096';
    expect(resolveNativeAttachmentLimits()).toEqual({ maxCount: 3, maxBytes: 4096 });
  });

  it('ignores invalid environment overrides', () => {
    process.env.OPENCODE_NATIVE_ATTACHMENT_MAX_COUNT = '0';
    process.env.OPENCODE_NATIVE_ATTACHMENT_MAX_BYTES = '25mb';
    expect(resolveNativeAttachmentLimits()).toEqual({ maxCount: 8, maxBytes: 25 * 1024 * 1024 });
  });
});

describe('buildPromptParts', () => {
  it('carries native media on opening and follow-up prompt construction', () => {
    expect(buildPromptParts('what is this?', [attachment('cat.png', 'image/png')], inspect, generous)).toEqual([
      { type: 'text', text: 'what is this?' },
      {
        type: 'file',
        mime: 'image/png',
        filename: 'msg-1--cat.png',
        url: 'file:///workspace/inbox/msg-1/cat.png',
      },
    ]);
  });

  it('stays text-only when there are no accepted attachments', () => {
    expect(buildPromptParts('just words', undefined, inspect, generous)).toEqual([
      { type: 'text', text: 'just words' },
    ]);
  });
});

import { describe, it, expect, afterEach } from 'bun:test';

import { buildOpenCodeConfig, resolveOpenCodePromptModel } from './opencode-config.js';

const ENV_KEYS = [
  'OPENCODE_PROVIDER',
  'OPENCODE_MODEL',
  'OPENCODE_SMALL_MODEL',
  'ANTHROPIC_BASE_URL',
  'OPENCODE_BASE_URL',
  'OPENCODE_MODEL_CONTEXT_LIMIT',
  'OPENCODE_MODEL_OUTPUT_LIMIT',
  'OPENCODE_MODEL_INPUT_MODALITIES',
] as const;
const saved = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
afterEach(() => {
  for (const k of ENV_KEYS) {
    if (saved[k] === undefined) delete process.env[k];
    else process.env[k] = saved[k];
  }
});

describe('resolveOpenCodePromptModel', () => {
  it('splits the configured provider/model for the prompt API', () => {
    expect(resolveOpenCodePromptModel({ model: 'openai/gpt-5.6-sol' })).toEqual({
      providerID: 'openai',
      modelID: 'gpt-5.6-sol',
    });
    expect(resolveOpenCodePromptModel({ model: 'openrouter/anthropic/claude-sonnet-4' })).toEqual({
      providerID: 'openrouter',
      modelID: 'anthropic/claude-sonnet-4',
    });
  });

  it('leaves OpenCode its default for a missing or malformed model', () => {
    expect(resolveOpenCodePromptModel({})).toBeUndefined();
    expect(resolveOpenCodePromptModel({ model: 'gpt-5.6-sol' })).toBeUndefined();
    expect(resolveOpenCodePromptModel({ model: 'openai/' })).toBeUndefined();
  });
});

describe('buildOpenCodeConfig provider transport', () => {
  it('allows the core five-minute human-question window plus transport overhead', () => {
    expect(buildOpenCodeConfig({}).experimental).toMatchObject({ mcp_timeout: 330_000 });
  });
  it('treats a custom provider prefix literally rather than as a regular expression', () => {
    process.env.OPENCODE_PROVIDER = 'local[1]';
    process.env.OPENCODE_MODEL = 'local[1]/model';
    process.env.OPENCODE_SMALL_MODEL = 'local[1]/small';
    const config = buildOpenCodeConfig({});
    expect(config.provider).toMatchObject({
      'local[1]': { models: { model: { id: 'model' }, small: { id: 'small' } } },
    });
  });
  it('uses ProviderOptions.model before the compatibility env fallback', () => {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.OPENCODE_MODEL = 'openai/legacy-model';
    const config = buildOpenCodeConfig({ model: 'openai/typed-model' });
    expect(config.model).toBe('openai/typed-model');
  });

  it('falls back to OPENCODE_MODEL when ProviderOptions.model is omitted', () => {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.OPENCODE_MODEL = 'openai/legacy-model';
    const config = buildOpenCodeConfig({});
    expect(config.model).toBe('openai/legacy-model');
  });

  it('native cloud providers receive the OneCLI placeholder without an endpoint override', () => {
    process.env.OPENCODE_PROVIDER = 'anthropic';
    process.env.OPENCODE_MODEL = 'anthropic/claude-sonnet-4-6';
    delete process.env.ANTHROPIC_BASE_URL;
    const config = buildOpenCodeConfig({});
    expect(config.provider).toMatchObject({ anthropic: { options: { apiKey: 'nc-opencode-token-v1' } } });
  });

  it('custom base URL pins the Chat Completions transport', () => {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.OPENCODE_MODEL = 'openai/some/local-model';
    process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
    const config = buildOpenCodeConfig({});
    const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
    expect(entry.npm).toBe('@ai-sdk/openai-compatible');
    expect(entry.options).toEqual({ apiKey: 'nc-opencode-token-v1', baseURL: 'https://inference.example.test/v1' });
  });

  it('no base URL keeps the native transport and still passes inference overrides', () => {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.OPENCODE_MODEL = 'openai/gpt-5.2';
    delete process.env.ANTHROPIC_BASE_URL;
    const config = buildOpenCodeConfig({ effort: 'high' });
    const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
    expect(entry.options).toEqual({ apiKey: 'nc-opencode-token-v1' });
    expect(entry.npm).toBeUndefined();
    expect(entry.models).toMatchObject({ 'gpt-5.2': { options: { reasoningEffort: 'high' } } });
  });

  it('openrouter with a base URL keeps its native transport (no pin)', () => {
    process.env.OPENCODE_PROVIDER = 'openrouter';
    process.env.OPENCODE_MODEL = 'openrouter/some/model';
    process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
    const config = buildOpenCodeConfig({});
    const entry = (config.provider as Record<string, Record<string, unknown>>).openrouter;
    expect(entry.npm).toBeUndefined();
  });

  it('openai with a base URL still pins the Chat Completions transport', () => {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.OPENCODE_MODEL = 'openai/some/local-model';
    process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
    const config = buildOpenCodeConfig({});
    const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
    expect(entry.npm).toBe('@ai-sdk/openai-compatible');
  });
});

describe('buildOpenCodeConfig model limit', () => {
  function limitEnv() {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.OPENCODE_MODEL = 'openai/some/local-model';
    process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
  }

  function limit(config: Record<string, unknown>) {
    const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
    return (entry.models as Record<string, Record<string, unknown>>)['some/local-model'].limit;
  }

  // buildOpenCodeConfig logs through console.error (see `log` at the top of
  // opencode.ts); capture it so the invalid-input tests can assert on the
  // message instead of just the silent absence of a limit. `spyOn(console,
  // 'error')` does not intercept calls made from other modules on this Bun
  // version, so patch the method directly.
  function captureErrors(fn: () => Record<string, unknown>) {
    const messages: string[] = [];
    const original = console.error;
    console.error = ((...args: unknown[]) => {
      messages.push(String(args[0]));
    }) as typeof console.error;
    try {
      return { config: fn(), messages };
    } finally {
      console.error = original;
    }
  }

  it('declares limit.context/output on the registered model when both env vars are set', () => {
    limitEnv();
    process.env.OPENCODE_MODEL_CONTEXT_LIMIT = '65536';
    process.env.OPENCODE_MODEL_OUTPUT_LIMIT = '8192';
    const config = buildOpenCodeConfig({});
    expect(limit(config)).toEqual({ context: 65536, output: 8192 });
  });

  it('omits limit when the env vars are unset', () => {
    limitEnv();
    delete process.env.OPENCODE_MODEL_CONTEXT_LIMIT;
    delete process.env.OPENCODE_MODEL_OUTPUT_LIMIT;
    const config = buildOpenCodeConfig({});
    expect(limit(config)).toBeUndefined();
  });

  it.each([[' '], ['64k'], ['0'], ['-5']])(
    'rejects OPENCODE_MODEL_CONTEXT_LIMIT=%p, omits limit, and logs the rejection',
    (value) => {
      limitEnv();
      process.env.OPENCODE_MODEL_CONTEXT_LIMIT = value;
      delete process.env.OPENCODE_MODEL_OUTPUT_LIMIT;
      const { config, messages } = captureErrors(() => buildOpenCodeConfig({}));
      expect(limit(config)).toBeUndefined();
      expect(messages.some((m) => m.includes('Ignoring invalid OPENCODE_MODEL_CONTEXT_LIMIT'))).toBe(true);
    },
  );

  it('ignores a set OPENCODE_MODEL_OUTPUT_LIMIT when there is no valid context limit, and logs it', () => {
    limitEnv();
    delete process.env.OPENCODE_MODEL_CONTEXT_LIMIT;
    process.env.OPENCODE_MODEL_OUTPUT_LIMIT = '8192';
    const { config, messages } = captureErrors(() => buildOpenCodeConfig({}));
    expect(limit(config)).toBeUndefined();
    expect(
      messages.some(
        (m) => m.includes('Ignoring OPENCODE_MODEL_OUTPUT_LIMIT') && m.includes('OPENCODE_MODEL_CONTEXT_LIMIT'),
      ),
    ).toBe(true);
  });
});

describe('buildOpenCodeConfig model input modalities', () => {
  function models(config: Record<string, unknown>) {
    const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
    return (entry.models as Record<string, Record<string, unknown>>)['some/local-model'];
  }

  function customModelEnv() {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.OPENCODE_MODEL = 'openai/some/local-model';
    process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
  }

  it('declares attachment + modalities so file parts survive the model call', () => {
    customModelEnv();
    process.env.OPENCODE_MODEL_INPUT_MODALITIES = 'image,pdf';
    const model = models(buildOpenCodeConfig({}));
    expect(model.attachment).toBe(true);
    // `text` is always prepended: the declared input list REPLACES the defaults,
    // so omitting it would turn off text input on the model entry.
    expect(model.modalities).toEqual({ input: ['text', 'image', 'pdf'], output: ['text'] });
  });

  it('omits both capability keys when the env var is unset', () => {
    customModelEnv();
    delete process.env.OPENCODE_MODEL_INPUT_MODALITIES;
    const model = models(buildOpenCodeConfig({}));
    expect(model.attachment).toBeUndefined();
    expect(model.modalities).toBeUndefined();
  });

  it('omits both capability keys when the env var is empty or only separators', () => {
    customModelEnv();
    process.env.OPENCODE_MODEL_INPUT_MODALITIES = ' , ,';
    const model = models(buildOpenCodeConfig({}));
    expect(model.attachment).toBeUndefined();
    expect(model.modalities).toBeUndefined();
  });

  it('drops entries outside the schema enum and keeps the valid ones', () => {
    customModelEnv();
    process.env.OPENCODE_MODEL_INPUT_MODALITIES = ' IMAGE , hologram, pdf ,image';
    const model = models(buildOpenCodeConfig({}));
    expect(model.modalities).toEqual({ input: ['text', 'image', 'pdf'], output: ['text'] });
  });

  it('does not duplicate text when the operator lists it explicitly', () => {
    customModelEnv();
    process.env.OPENCODE_MODEL_INPUT_MODALITIES = 'text,image';
    const model = models(buildOpenCodeConfig({}));
    expect(model.modalities).toEqual({ input: ['text', 'image'], output: ['text'] });
  });
});

describe('buildOpenCodeConfig small model scope', () => {
  function scopeEnv() {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.OPENCODE_MODEL = 'openai/main/model';
    process.env.ANTHROPIC_BASE_URL = 'https://inference.example.test/v1';
    process.env.OPENCODE_MODEL_CONTEXT_LIMIT = '65536';
    process.env.OPENCODE_MODEL_OUTPUT_LIMIT = '8192';
    process.env.OPENCODE_MODEL_INPUT_MODALITIES = 'image,pdf';
  }

  function models(config: Record<string, unknown>) {
    const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
    return entry.models as Record<string, Record<string, unknown>>;
  }

  it('applies limit and modalities to the main model only, leaving a distinct small model bare', () => {
    scopeEnv();
    process.env.OPENCODE_SMALL_MODEL = 'openai/small/model';
    const all = models(buildOpenCodeConfig({}));

    expect(all['main/model']).toEqual({
      id: 'main/model',
      name: 'main/model',
      tool_call: true,
      limit: { context: 65536, output: 8192 },
      attachment: true,
      modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
    });
    // A distinct small model carries neither key — an undeclared context
    // window / modality set is the safe default it falls back to.
    expect(all['small/model']).toEqual({ id: 'small/model', name: 'small/model', tool_call: true });
  });

  it('small model unset or equal to the main model keeps the pre-existing single-entry shape', () => {
    scopeEnv();
    delete process.env.OPENCODE_SMALL_MODEL;
    const unset = models(buildOpenCodeConfig({}));

    process.env.OPENCODE_SMALL_MODEL = 'openai/main/model'; // same as OPENCODE_MODEL
    const same = models(buildOpenCodeConfig({}));

    const expected = {
      'main/model': {
        id: 'main/model',
        name: 'main/model',
        tool_call: true,
        limit: { context: 65536, output: 8192 },
        attachment: true,
        modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
      },
    };
    expect(unset).toEqual(expected);
    expect(same).toEqual(expected);
  });
});

// The instructions array is covered in opencode.memory.test.ts, where the
// memory-delivery contract it used to (wrongly) carry now lives.

describe('buildOpenCodeConfig permission', () => {
  it('pins `question` to deny deterministically instead of a wildcard string', () => {
    const config = buildOpenCodeConfig({});
    // A flat 'allow' string previously left `question` to OpenCode's own
    // resolution, which produced contradictory rules (question -> deny *
    // AND question -> allow * for the same session, observed live). An
    // explicit object with one value per category can never produce that:
    // there is exactly one entry for `question`, and it is not 'allow'.
    expect(typeof config.permission).toBe('object');
    expect(config.permission).not.toBe('allow');
    const permission = config.permission as Record<string, unknown>;
    expect(permission.question).toBe('deny');
  });

  it('keeps every other known permission category on allow (no capability regression)', () => {
    const config = buildOpenCodeConfig({});
    const permission = config.permission as Record<string, unknown>;
    const nonQuestionKeys = Object.keys(permission).filter((k) => k !== 'question');
    expect(nonQuestionKeys.length).toBeGreaterThan(0);
    for (const key of nonQuestionKeys) {
      expect(permission[key]).toBe('allow');
    }
  });
});

describe('buildOpenCodeConfig reasoning effort', () => {
  function effortEnv() {
    process.env.OPENCODE_PROVIDER = 'opencode-go';
    process.env.OPENCODE_MODEL = 'opencode-go/deepseek-v4-flash';
    process.env.ANTHROPIC_BASE_URL = 'https://opencode.ai/zen/go/v1';
    delete process.env.OPENCODE_SMALL_MODEL;
  }

  function modelOptions(config: Record<string, unknown>, modelId: string) {
    const entry = (config.provider as Record<string, Record<string, unknown>>)['opencode-go'];
    return (entry.models as Record<string, Record<string, unknown>>)[modelId].options;
  }

  it('emits reasoningEffort on the main model when the group config sets an effort', () => {
    effortEnv();
    const config = buildOpenCodeConfig({ effort: 'max' });
    expect(modelOptions(config, 'deepseek-v4-flash')).toEqual({ reasoningEffort: 'max' });
  });

  it('omits model options when no effort is set', () => {
    effortEnv();
    const config = buildOpenCodeConfig({});
    expect(modelOptions(config, 'deepseek-v4-flash')).toBeUndefined();
  });

  it('leaves a distinct small model untouched', () => {
    effortEnv();
    process.env.OPENCODE_SMALL_MODEL = 'opencode-go/deepseek-v4-flash-lite';
    const config = buildOpenCodeConfig({ effort: 'high' });
    expect(modelOptions(config, 'deepseek-v4-flash')).toEqual({ reasoningEffort: 'high' });
    expect(modelOptions(config, 'deepseek-v4-flash-lite')).toBeUndefined();
  });
});

describe('provider-owned endpoint defaults', () => {
  it('uses OpenCode endpoint without changing the historical shared fallback', () => {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.ANTHROPIC_BASE_URL = 'https://claude.example.test';
    process.env.OPENCODE_BASE_URL = 'http://localhost:8891/v1';
    const config = buildOpenCodeConfig({ model: 'openai/test' });
    expect(config.provider).toMatchObject({ openai: { options: { baseURL: 'http://localhost:8891/v1' } } });
    expect(process.env.ANTHROPIC_BASE_URL).toBe('https://claude.example.test');
  });
  it('explicit native endpoint suppresses a shared Claude URL and preserves model limits', () => {
    process.env.OPENCODE_PROVIDER = 'openai';
    process.env.OPENCODE_BASE_URL = 'native';
    process.env.ANTHROPIC_BASE_URL = 'https://claude.example.test';
    process.env.OPENCODE_MODEL_CONTEXT_LIMIT = '32768';
    process.env.OPENCODE_MODEL_OUTPUT_LIMIT = '4096';
    const config = buildOpenCodeConfig({ model: 'openai/test', effort: 'high' });
    const entry = (config.provider as Record<string, Record<string, unknown>>).openai;
    expect(entry.options).toEqual({ apiKey: 'nc-opencode-token-v1' });
    expect(entry.npm).toBeUndefined();
    expect(entry.models).toMatchObject({
      test: { limit: { context: 32768, output: 4096 }, options: { reasoningEffort: 'high' } },
    });
  });
});

import './index.js';
import { opencodeRuntimeContract } from '../provider-contracts/opencode.js';
import { defineProviderConformance } from '../provider-contracts/testing/conformance.js';

defineProviderConformance('opencode', opencodeRuntimeContract);

import { afterEach, describe, expect, it, mock } from 'bun:test';
import {
  executeOpenCodeTurn,
  OpenCodeEventPump,
  createOpenCodeMessageId,
  type OpenCodeEvent,
  type OpenCodeMessage,
  type OpenCodeSessionClient,
} from './opencode-turn.js';

const cleanups: Array<() => void> = [];
afterEach(() => {
  for (const cleanup of cleanups.splice(0)) cleanup();
});

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (error: Error) => void;
  const promise = new Promise<T>((yes, no) => {
    resolve = yes;
    reject = no;
  });
  return { promise, resolve, reject };
}

function fixture() {
  const events: OpenCodeEvent[] = [{ type: 'server.connected', properties: {} }];
  let wake: (() => void) | undefined;
  let closed = false;
  let subscribed = false;
  const emit = (event: OpenCodeEvent) => {
    events.push(event);
    wake?.();
  };
  const pump = new OpenCodeEventPump(
    (async function* () {
      subscribed = true;
      while (!closed) {
        if (!events.length)
          await new Promise<void>((resolve) => {
            wake = resolve;
          });
        const event = events.shift();
        if (event) yield event;
      }
    })(),
    () => {},
  );
  const close = () => {
    closed = true;
    wake?.();
  };
  cleanups.push(close);
  const history: OpenCodeMessage[] = [];
  let request = deferred<{ data?: OpenCodeMessage; error?: unknown }>();
  let marker = '';
  const prompts: Parameters<OpenCodeSessionClient['prompt']>[0][] = [];
  const abort = mock(async () => {
    request.resolve({ error: { name: 'MessageAbortedError' } });
    return {};
  });
  const client: OpenCodeSessionClient = {
    create: async () => ({ data: { id: 'ses_test' } }),
    prompt: (params) => {
      expect(subscribed).toBe(true);
      prompts.push(params);
      marker = params.body.messageID;
      history.push({ info: { id: marker, role: 'user', time: { created: Date.now() } }, parts: [] });
      request = deferred();
      return request.promise;
    },
    messages: async (params) => ({ data: history.slice(-params.query.limit) }),
    abort,
  };
  const discard = mock(close);
  const runtime = {};
  const run = (
    signal = new AbortController().signal,
    overrides: Partial<Parameters<typeof executeOpenCodeTurn>[0]> = {},
  ) =>
    executeOpenCodeTurn({
      runtime,
      client,
      pump,
      sessionId: 'ses_test',
      parts: [{ type: 'text', text: 'test' }],
      signal,
      silenceMs: 10000,
      idleMs: 10000,
      discard,
      ...overrides,
    });
  const assistant = (id: string, text: string[], extra: Partial<OpenCodeMessage['info']> = {}): OpenCodeMessage => ({
    info: { id, role: 'assistant', parentID: marker, time: { created: Date.now(), completed: Date.now() }, ...extra },
    parts: text.map((text, index) => ({ id: `prt_${id}_${index}`, type: 'text', text })),
  });
  const complete = (message = assistant('msg_answer', ['answer'])) => {
    history.push(message);
    request.resolve({ data: message });
  };
  return {
    run,
    history,
    emit,
    client,
    abort,
    prompts,
    complete,
    assistant,
    discard,
    get request() {
      return request;
    },
    get marker() {
      return marker;
    },
  };
}

async function collectTurn(turn: ReturnType<typeof executeOpenCodeTurn>) {
  const events: Array<{ type: string }> = [];
  while (true) {
    const event = await turn.next();
    if (event.done) return { result: event.value, events };
    events.push(event.value);
  }
}
async function collect(turn: ReturnType<typeof executeOpenCodeTurn>) {
  return (await collectTurn(turn)).result.text;
}
async function prompted(f: ReturnType<typeof fixture>, count = 1) {
  for (let attempt = 0; attempt < 1000 && f.prompts.length < count; attempt++) await Bun.sleep(1);
  expect(f.prompts.length).toBe(count);
}

describe('configured model on every prompt', () => {
  it('names the configured model in the prompt body so a resumed session follows configuration changes', async () => {
    const f = fixture();
    const done = collect(f.run(undefined, { model: { providerID: 'openai', modelID: 'gpt-5.6-sol' } }));
    await prompted(f);
    expect(f.prompts[0]?.body.model).toEqual({ providerID: 'openai', modelID: 'gpt-5.6-sol' });
    f.complete();
    expect(await done).toBe('answer');
  });

  it('omits the model when none is configured, leaving OpenCode its default', async () => {
    const f = fixture();
    const done = collect(f.run());
    await prompted(f);
    expect(f.prompts[0]?.body).not.toHaveProperty('model');
    f.complete();
    expect(await done).toBe('answer');
  });
});

describe('verified OpenCode turn completion', () => {
  it('starts the lazy SSE subscription before the first prompt and preserves native ID shape', async () => {
    const f = fixture();
    const result = collect(f.run());
    await prompted(f);
    expect(f.marker).toMatch(/^msg_[a-f0-9]{12}[A-Za-z0-9]{14}$/);
    expect(new Set(Array.from({ length: 100 }, createOpenCodeMessageId)).size).toBe(100);
    f.complete();
    expect(await result).toBe('answer');
  });

  it('ignores stale idle and recoverable overflow while the HTTP turn remains active', async () => {
    const f = fixture();
    let settled = false;
    const result = collect(f.run()).finally(() => {
      settled = true;
    });
    await prompted(f);
    f.emit({ type: 'session.idle', properties: { sessionID: 'ses_test' } });
    f.emit({ type: 'session.error', properties: { sessionID: 'ses_test', error: { name: 'ContextOverflowError' } } });
    await Bun.sleep(10);
    expect(settled).toBe(false);
    expect(f.prompts).toHaveLength(1);
    f.complete();
    expect(await result).toBe('answer');
    expect(f.abort).not.toHaveBeenCalled();
  });

  it('collects all text parts and assistant messages, excluding prior output and compaction summaries', async () => {
    const f = fixture();
    const created = Date.now() + 1000;
    f.history.push({ info: { id: 'msg_old_user', role: 'user', time: { created } }, parts: [] });
    const result = collect(f.run());
    await prompted(f);
    f.history.push(f.assistant('msg_old_assistant', ['old output'], { parentID: 'msg_old_user' }));
    const first = f.assistant('msg_first', ['<message to="a">one</message>', '<message to="b">two</message>']);
    f.history.unshift(first); // Native/client counters need not sort parent before child.
    f.history.push(f.assistant('msg_summary', ['<message to="a">do not send summary</message>'], { summary: true }));
    const replay = 'msg_replay';
    f.history.push({ info: { id: replay, role: 'user', time: { created: Date.now() } }, parts: [] });
    const final = f.assistant('msg_final', ['<message to="c">three</message>'], { parentID: replay });
    final.parts.push(first.parts[0]); // Repeated part ID is delivered once.
    f.complete(final);
    expect(await result).toBe(
      '<message to="a">one</message>\n\n<message to="b">two</message>\n\n<message to="c">three</message>',
    );
  });

  it('does not replay when the response belongs to an older assistant', async () => {
    const f = fixture();
    const result = collect(f.run());
    await prompted(f);
    f.complete(f.assistant('msg_old', ['old'], { parentID: 'msg_previous' }));
    await expect(result).rejects.toThrow('another turn');
    expect(f.prompts).toHaveLength(1);
    expect(f.abort).not.toHaveBeenCalled();
  });

  it('fails visibly when history cannot prove the prompt', async () => {
    const f = fixture();
    const result = collect(f.run());
    await prompted(f);
    f.history.length = 0;
    f.complete();
    await expect(result).rejects.toThrow('verifiable prompt');
    expect(f.prompts).toHaveLength(1);
  });

  it('surfaces a completed native error as one final error result without aborting an idle session', async () => {
    const f = fixture();
    const result = collectTurn(f.run());
    await prompted(f);
    f.complete(
      f.assistant('msg_failed', [], { error: { name: 'APIError', data: { message: 'backend rejected request' } } }),
    );
    const completed = await result;
    expect(completed.result.isError).toBe(true);
    expect(completed.result.text).toBeNull();
    expect(completed.events).toEqual([
      { type: 'error', message: expect.stringContaining('backend rejected request'), retryable: false },
    ]);
    expect(f.abort).not.toHaveBeenCalled();
  });

  it('preserves only completed text from this prompt when a later native step fails', async () => {
    const f = fixture();
    f.history.push({ info: { id: 'msg_prior_user', role: 'user', time: { created: Date.now() + 1000 } }, parts: [] });
    const result = collectTurn(f.run());
    await prompted(f);
    f.history.push(f.assistant('msg_prior', ['PRIOR_TURN'], { parentID: 'msg_prior_user' }));
    f.history.push(f.assistant('msg_done', ['<message to="a">COMPLETED_STEP</message>']));
    f.history.push(f.assistant('msg_summary', ['INTERNAL_SUMMARY'], { summary: true }));
    f.history.push(f.assistant('msg_unfinished', ['UNFINISHED_STEP'], { time: { created: Date.now() } }));
    f.complete(
      f.assistant('msg_failed', ['FAILED_STEP'], {
        error: {
          name: 'APIError',
          data: {
            message: 'FINAL_STEP_FAILED',
            responseBody: '<message to="a">RAW_DIAGNOSTIC_MUST_NOT_DELIVER</message>',
            responseHeaders: { 'x-fixture': 'RAW_HEADER' },
          },
        },
      }),
    );
    const completed = await result;
    expect(completed.result).toEqual({
      text: '<message to="a">COMPLETED_STEP</message>',
      isError: true,
    });
    expect(completed.events.filter((event) => event.type === 'error')).toHaveLength(1);
    expect(completed.events).toContainEqual({
      type: 'error',
      message: expect.stringContaining('RAW_DIAGNOSTIC_MUST_NOT_DELIVER'),
      retryable: false,
    });
    expect(f.prompts).toHaveLength(1);
    expect(f.abort).not.toHaveBeenCalled();
  });

  it('lets native retries finish while keeping a second prompt queued', async () => {
    const f = fixture();
    const first = collect(f.run());
    await prompted(f);
    const second = collect(f.run());
    for (let attempt = 1; attempt <= 5; attempt++) {
      f.emit({ type: 'session.status', properties: { sessionID: 'ses_test', status: { type: 'retry', attempt } } });
      await Bun.sleep(1);
      expect(f.prompts).toHaveLength(1);
      expect(f.abort).not.toHaveBeenCalled();
    }
    f.complete();
    expect(await first).toBe('answer');
    await prompted(f, 2);
    f.complete();
    expect(await second).toBe('answer');
  });

  it('gives every history page its own request budget after native completion', async () => {
    const f = fixture();
    const messages = f.client.messages;
    const reads: number[] = [];
    f.client.messages = async (params) => {
      if (f.prompts.length) {
        reads.push(params.query.limit);
        await Bun.sleep(1600);
      }
      return messages(params);
    };
    const result = collect(f.run(undefined, { silenceMs: 60000, idleMs: 60000 }));
    await prompted(f);
    for (let step = 0; step < 3300; step++) f.history.push(f.assistant(`msg_step_${step}`, []));
    f.complete();
    expect(await result).toBe('answer');
    expect(reads).toEqual([100, 200, 400, 800, 1600, 3200, 6400]);
    expect(f.prompts).toHaveLength(1);
    expect(f.abort).not.toHaveBeenCalled();
    expect(f.discard).not.toHaveBeenCalled();
  }, 20000);

  it('does not abort completed native execution when a later history read fails', async () => {
    const f = fixture();
    const messages = f.client.messages;
    f.client.messages = async (params) =>
      f.prompts.length
        ? { error: { name: 'StorageError', data: { message: 'History unavailable' } } }
        : messages(params);
    const result = collect(f.run());
    await prompted(f);
    f.complete();
    await expect(result).rejects.toThrow('History unavailable');
    expect(f.abort).not.toHaveBeenCalled();
    expect(f.prompts).toHaveLength(1);
  });

  it('explicitly aborts and discards uncertain native execution after HTTP disconnect', async () => {
    const f = fixture();
    const result = collect(f.run());
    await prompted(f);
    f.request.reject(new Error('connection reset'));
    await expect(result).rejects.toThrow('connection reset');
    expect(f.abort).toHaveBeenCalledTimes(1);
    expect(f.discard).toHaveBeenCalledTimes(1);
  });

  it('cancels a queued query promptly without aborting the earlier turn', async () => {
    const f = fixture();
    const first = collect(f.run());
    await prompted(f);
    const cancel = new AbortController();
    const second = collect(f.run(cancel.signal));
    cancel.abort();
    await expect(second).rejects.toThrow('aborted');
    expect(f.abort).not.toHaveBeenCalled();
    f.complete();
    expect(await first).toBe('answer');
  });

  it('waits for original HTTP completion after an abort that raced prompt registration', async () => {
    const f = fixture();
    const cancel = new AbortController();
    f.abort.mockImplementation(async () => ({}));
    let settled = false;
    const result = collect(f.run(cancel.signal)).finally(() => {
      settled = true;
    });
    await prompted(f);
    cancel.abort();
    await Bun.sleep(10);
    expect(f.abort).toHaveBeenCalledTimes(1);
    expect(settled).toBe(false);
    f.request.resolve({ error: { name: 'MessageAbortedError' } });
    await expect(result).rejects.toThrow('aborted');
    expect(f.discard).not.toHaveBeenCalled();
  });

  it('aborts when the consumer closes the generator after an activity event', async () => {
    const f = fixture();
    const turn = f.run();
    const first = turn.next();
    await prompted(f);
    f.emit({ type: 'message.updated', properties: { info: { sessionID: 'ses_test', id: 'msg_work' } } });
    expect((await first).value).toEqual({ type: 'activity' });
    await turn.return({ text: null });
    expect(f.abort).toHaveBeenCalledTimes(1);
  });

  it('counts owned task-child activity while excluding an unrelated session', async () => {
    const f = fixture();
    const result = collect(f.run(undefined, { idleMs: 50 }));
    await prompted(f);
    f.emit({ type: 'session.created', properties: { info: { id: 'ses_child', parentID: 'ses_test' } } });
    for (let step = 0; step < 8; step++) {
      f.emit({ type: 'message.part.updated', properties: { part: { sessionID: 'ses_child' } } });
      await Bun.sleep(10);
    }
    f.complete();
    expect(await result).toBe('answer');
    expect(f.abort).not.toHaveBeenCalled();

    const second = collect(f.run(undefined, { idleMs: 40 }));
    const rejected = second.then(
      () => undefined,
      (error: Error) => error,
    );
    await prompted(f, 2);
    for (let step = 0; step < 6; step++) {
      f.emit({ type: 'message.part.updated', properties: { part: { sessionID: 'ses_unrelated' } } });
      await Bun.sleep(10);
    }
    expect((await rejected)?.message).toContain('no activity');
  });
});

import { describe, it, expect } from 'bun:test';

import { createProvider } from './factory.js';
import { OpenCodeProvider } from './opencode.js';

describe('createProvider (opencode)', () => {
  it('returns OpenCodeProvider for opencode', () => {
    expect(createProvider('opencode')).toBeInstanceOf(OpenCodeProvider);
  });
});

import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
import fs from 'fs';
import os from 'os';
import path from 'path';

import { OpenCodeProvider } from './opencode.js';
import { buildOpenCodeConfig } from './opencode-config.js';
import {
  prepareOpenCodeMemory,
  openCodeInstructionsPath,
  runMemorySessionHook,
  type OpenCodeMemorySessionHook,
} from './opencode-memory.js';

// The same registered renderer used by other providers supplies a turn-start
// snapshot. Native OpenCode rereads its output file during that turn.

const MARKER = '<<memory-block>>';

let dir: string;
let scriptSeq = 0;

function logPath(): string {
  return path.join(dir, 'stdin.log');
}

/** Payloads the hook command received, one per invocation, in order. */
function invocations(): string[] {
  if (!fs.existsSync(logPath())) return [];
  return fs
    .readFileSync(logPath(), 'utf-8')
    .split('\n')
    .filter((line) => line.length > 0);
}

/**
 * A stand-in for `bun /app/src/memory/hook.ts`: appends its stdin to the log,
 * prints `body` on stdout, exits with `exitCode`.
 */
function fakeHook(opts: { body?: string; exitCode?: number } = {}): OpenCodeMemorySessionHook {
  const body = opts.body ?? MARKER;
  const script = path.join(dir, `hook-${scriptSeq++}.sh`);
  fs.writeFileSync(
    script,
    [
      '#!/bin/sh',
      `cat >> "${logPath()}"`,
      `echo "" >> "${logPath()}"`,
      `cat <<'EOF'`,
      body,
      'EOF',
      `exit ${opts.exitCode ?? 0}`,
    ].join('\n') + '\n',
  );
  return { command: `sh ${script}`, legacyCommands: [], sources: ['startup', 'clear', 'compact'] };
}

beforeEach(() => {
  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencode-memory-'));
  scriptSeq = 0;
});
afterEach(() => {
  fs.rmSync(dir, { recursive: true, force: true });
});

describe('runMemorySessionHook', () => {
  it('feeds the hook the SessionStart lifecycle payload for the source it runs', () => {
    const hook = fakeHook();
    expect(runMemorySessionHook(hook, 'startup')).toBe(MARKER);
    expect(runMemorySessionHook(hook, 'compact')).toBe(MARKER);
    expect(invocations()).toEqual([
      '{"hook_event_name":"SessionStart","source":"startup"}',
      '{"hook_event_name":"SessionStart","source":"compact"}',
    ]);
  });

  it('injects the command output verbatim — truncation belongs to the shared renderer', () => {
    // Far past the shared renderer's 16k-per-file budget: whatever the command
    // decided to print is what gets injected, uncut, so the caps live in one
    // place instead of being re-implemented (and double-applied) here.
    const big = 'x'.repeat(40_000);
    const out = runMemorySessionHook(fakeHook({ body: big }), 'startup');
    expect(out).toBe(big);
    expect(out).toHaveLength(40_000);
  });

  it('distinguishes renderer failure from successfully empty output', () => {
    expect(runMemorySessionHook(fakeHook({ exitCode: 3 }), 'startup')).toBeUndefined();
    expect(runMemorySessionHook(fakeHook({ body: '' }), 'startup')).toBe('');
    expect(runMemorySessionHook(undefined, 'startup')).toBeUndefined();
    expect(
      runMemorySessionHook(
        { command: path.join(dir, 'does-not-exist.sh'), legacyCommands: [], sources: ['startup'] },
        'startup',
      ),
    ).toBeUndefined();
  });

  it('skips a source the registration does not declare', () => {
    const hook = { ...fakeHook(), sources: ['startup'] as const };
    expect(runMemorySessionHook(hook, 'compact')).toBeUndefined();
    expect(invocations()).toEqual([]);
  });
});

describe('rendered turn instructions', () => {
  it('writes rendered memory, core instructions and delivery wording into one private file', () => {
    const file = path.join(dir, 'turn.md');
    prepareOpenCodeMemory(fakeHook(), 'CORE', 'ROUTING', file);
    expect(fs.readFileSync(file, 'utf8')).toBe(`${MARKER}\n\nCORE\n\nROUTING`);
    expect(fs.statSync(file).mode & 0o777).toBe(0o600);
    expect(invocations()).toEqual(['{"hook_event_name":"SessionStart","source":"startup"}']);
  });

  it('refreshes the same file on each external turn, including a resumed session', () => {
    const file = path.join(dir, 'turn.md');
    prepareOpenCodeMemory(fakeHook(), 'OLD', 'OLD ROUTING', file);
    prepareOpenCodeMemory(fakeHook({ body: 'FRESH' }), 'CURRENT', 'ROUTING', file);
    expect(fs.readFileSync(file, 'utf8')).toBe('FRESH\n\nCURRENT\n\nROUTING');
    expect(invocations()).toHaveLength(2);
  });

  it('keeps current instructions when rendering fails and does not resurrect stale memory', () => {
    const file = path.join(dir, 'turn.md');
    prepareOpenCodeMemory(fakeHook(), 'OLD', '', file);
    prepareOpenCodeMemory(fakeHook({ exitCode: 1 }), 'CURRENT', 'ROUTING', file);
    expect(fs.readFileSync(file, 'utf8')).toBe('CURRENT\n\nROUTING');
    prepareOpenCodeMemory(fakeHook({ body: '' }), 'NEW', '', file);
    expect(fs.readFileSync(file, 'utf8')).toBe('NEW');
  });
});

describe('OpenCodeProvider memory registration', () => {
  it('refuses to start a query when the shared hook was never registered', () => {
    expect(() => new OpenCodeProvider().query({ prompt: 'hi', cwd: '/workspace' })).toThrow(
      /memory session hook was not registered/i,
    );
  });

  it('does not run startup before the lazy query actually creates a session', () => {
    const provider = new OpenCodeProvider();
    provider.registerMemorySessionHook(fakeHook());
    provider.query({ prompt: 'hi', cwd: '/workspace' });
    provider.query({ prompt: 'hi again', cwd: '/workspace', continuation: 'ses_existing' });
    expect(invocations()).toEqual([]);
  });
});

describe('buildOpenCodeConfig instructions', () => {
  it('loads the rendered turn file, preserving the shared renderer caps on raw memory', () => {
    const config = buildOpenCodeConfig({});
    expect(config.instructions).toContain(openCodeInstructionsPath());
    expect(config).not.toHaveProperty('plugin');
    expect(config.instructions).not.toContain('/workspace/agent/memory/index.md');
    expect(config.instructions).not.toContain('/workspace/agent/memory/system/definition.md');
  });

  it('loads the composed group instructions from the agent directory', () => {
    const config = buildOpenCodeConfig({});
    expect(config.instructions).toContain('/workspace/agent/CLAUDE.md');
    expect(config.instructions).toContain('/workspace/agent/CLAUDE.local.md');
  });
});

import { it } from 'bun:test';
import assert from 'node:assert/strict';
import { spawn, execFileSync } from 'node:child_process';
import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { createOpencodeClient } from '@opencode-ai/sdk';
import { createOpencodeClient as createQuestionClient } from '@opencode-ai/sdk/v2';
import { OpenCodeProvider, setSharedRuntimeDepsForTesting, destroySharedRuntime } from './opencode.js';
import { buildOpenCodeServerEnv } from './opencode-config.js';
import { openCodeInstructionsPath } from './opencode-memory.js';
import { initTestSessionDb, closeSessionDb } from '../mailbox/sqlite/connection.js';
import { registerAgentMailbox, resetAgentMailboxForTesting } from '../mailbox/index.js';
import { SqliteAgentMailbox } from '../mailbox/sqlite/index.js';

// Explicit integration check: OPENCODE_TEST_BINARY=/absolute/path/opencode bun test <this file>.
// The local model fixture exercises the pinned native server and SDK without account credentials.
it.skipIf(!process.env.OPENCODE_TEST_BINARY)(
  'runs native turns, compaction, inherited memory, cancellation and a 65-second MCP call',
  async () => {
    const binary = process.env.OPENCODE_TEST_BINARY!;
    assert.equal(execFileSync(binary, ['--version'], { encoding: 'utf8' }).trim(), '1.18.25');
    const savedDataHome = process.env.XDG_DATA_HOME;
    const root = mkdtempSync(path.join(tmpdir(), 'opencode-native-'));
    const records: unknown[] = [];
    let scenario = 'basic';
    let mainCalls = 0;
    const seen: Array<{
      scenario: string;
      title: boolean;
      compact: boolean;
      child: boolean;
      memory: string;
      body: any;
    }> = [];
    function streaming(text: string, tool?: { name: string; args: object }, usage = 100) {
      const chunk = (delta: unknown, finish_reason: string | null) => ({
        id: 'chatcmpl_fixture',
        object: 'chat.completion.chunk',
        created: 1,
        model: 'fixture',
        choices: [{ index: 0, delta, finish_reason }],
      });
      const delta: any = { role: 'assistant', content: text };
      if (tool)
        delta.tool_calls = [
          {
            index: 0,
            id: 'call_fixture_' + Date.now(),
            type: 'function',
            function: { name: tool.name, arguments: JSON.stringify(tool.args) },
          },
        ];
      return new Response(
        [
          chunk(delta, null),
          chunk({}, tool ? 'tool_calls' : 'stop'),
          {
            ...chunk({}, null),
            choices: [],
            usage: { prompt_tokens: usage, completion_tokens: 10, total_tokens: usage + 10 },
          },
        ]
          .map((value) => `data: ${JSON.stringify(value)}\n\n`)
          .join('') + 'data: [DONE]\n\n',
        { headers: { 'Content-Type': 'text/event-stream' } },
      );
    }
    const backend = Bun.serve({
      hostname: '127.0.0.1',
      port: 0,
      async fetch(request) {
        const body = (await request.json()) as any;
        records.push(body);
        const title = body.messages.some(
          (m: any) => m.role === 'system' && String(m.content).startsWith('You are a title generator'),
        );
        const compact = !title && !body.tools?.length;
        const child =
          scenario === 'child' &&
          body.messages.some((m: any) => m.role === 'user' && String(m.content).includes('CHILD_HELLO'));
        const memory = body.messages
          .filter((m: any) => m.role === 'system')
          .map((m: any) => m.content)
          .join('\n');
        seen.push({ scenario, title, compact, child, memory, body });
        if (title) return streaming('Fixture title');
        if (compact) return streaming('INTERNAL_COMPACTION_SUMMARY. Retain the task and continue.');
        if (child) return streaming('CHILD_WORK_COMPLETED');
        mainCalls++;
        if (scenario === 'overflow' && mainCalls === 1) {
          writeFileSync(path.join(root, 'memory-source'), 'MEMORY_AFTER_OVERFLOW');
          return Response.json(
            {
              error: {
                message: 'maximum context length exceeded',
                type: 'invalid_request_error',
                code: 'context_length_exceeded',
              },
            },
            { status: 400 },
          );
        }
        if (scenario === 'auto' && mainCalls === 1) {
          writeFileSync(path.join(root, 'memory-source'), 'MEMORY_AFTER_AUTO');
          // Prove native continuation rereads the configured file, not a cached
          // system string; normal runtime rendering stays fixed for this turn.
          appendFileSync(openCodeInstructionsPath(), '\nNATIVE_FILE_REREAD_PROOF');
          return streaming(
            '<message to="fixture">BEFORE_COMPACTION</message>',
            {
              name: 'bash',
              args: {
                command: `printf native-tool-proof > '${root}/workspace/tool-proof'`,
                description: 'Write fixture proof',
              },
            },
            19500,
          );
        }
        if (scenario === 'child' && mainCalls === 1)
          return streaming('', {
            name: 'task',
            args: { description: 'Fixture child task', prompt: 'CHILD_HELLO', subagent_type: 'general' },
          });
        if (['mcp', 'cancel'].includes(scenario) && mainCalls === 1)
          return streaming('', {
            name: body.tools.find((tool: any) => tool.function.name.endsWith('_hold')).function.name,
            args: { delay: scenario === 'cancel' ? 300000 : 65000 },
          });
        if (scenario === 'error')
          return Response.json(
            {
              error: {
                message: 'fixture authentication failed',
                type: 'authentication_error',
                code: 'invalid_api_key',
              },
            },
            { status: 401 },
          );
        return streaming(`<message to="fixture">NATIVE_${scenario.toUpperCase()}_PASS</message>`);
      },
    });
    const portProbe = Bun.serve({
      hostname: '127.0.0.1',
      port: 0,
      fetch() {
        return new Response('');
      },
    });
    const port = portProbe.port;
    portProbe.stop(true);
    process.env.XDG_DATA_HOME = path.join(root, 'data');
    mkdirSync(path.join(root, 'workspace'));
    writeFileSync(path.join(root, 'memory-source'), 'NATIVE_MEMORY_SNAPSHOT');
    writeFileSync(
      path.join(root, 'hook.sh'),
      `#!/bin/sh\ncat >> '${root}/hook-events.log'\nprintf '\\n' >> '${root}/hook-events.log'\ncat '${root}/memory-source'\n`,
    );
    const composedFactory = resetAgentMailboxForTesting();
    initTestSessionDb();
    registerAgentMailbox(() => new SqliteAgentMailbox());
    writeFileSync(
      path.join(root, 'mcp-fixture.mjs'),
      `import { writeFileSync } from 'node:fs';
import { Server } from ${JSON.stringify(import.meta.resolve('@modelcontextprotocol/sdk/server/index.js'))};
import { StdioServerTransport } from ${JSON.stringify(import.meta.resolve('@modelcontextprotocol/sdk/server/stdio.js'))};
import { CallToolRequestSchema, ListToolsRequestSchema } from ${JSON.stringify(import.meta.resolve('@modelcontextprotocol/sdk/types.js'))};
const server = new Server({ name: 'fixture', version: '1' }, { capabilities: { tools: {} } });
server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [{ name: 'hold', description: 'Wait for the requested milliseconds', inputSchema: { type: 'object', properties: { delay: { type: 'integer' } }, required: ['delay'] } }] }));
server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
  const delay = request.params.arguments?.delay;
  writeFileSync(${JSON.stringify(path.join(root, 'mcp-started'))}, String(delay));
  return await new Promise((resolve) => {
    const abort = () => { writeFileSync(${JSON.stringify(path.join(root, 'mcp-aborted'))}, String(delay)); clearTimeout(timer); resolve({ content: [{ type: 'text', text: 'ABORTED' }], isError: true }); };
    const timer = setTimeout(() => { extra.signal.removeEventListener('abort', abort); resolve({ content: [{ type: 'text', text: 'WAITED_' + delay }] }); }, delay);
    extra.signal.addEventListener('abort', abort, { once: true });
  });
});
await server.connect(new StdioServerTransport());
`,
    );
    let nativeLog = '';
    let spawnCount = 0;
    setSharedRuntimeDepsForTesting({
      spawnServer: async (config) => {
        spawnCount++;
        let spawnLog = '';
        const proc = spawn(binary, ['serve', '--hostname=127.0.0.1', `--port=${port}`], {
          cwd: path.join(root, 'workspace'),
          detached: true,
          env: buildOpenCodeServerEnv(config, {
            PATH: process.env.PATH,
            HOME: root,
            XDG_DATA_HOME: process.env.XDG_DATA_HOME,
            XDG_CONFIG_HOME: path.join(root, 'config'),
            XDG_CACHE_HOME: path.join(root, 'cache'),
            XDG_STATE_HOME: path.join(root, 'state'),
            OPENCODE_DISABLE_MODELS_FETCH: 'true',
          }),
          stdio: ['ignore', 'pipe', 'pipe'],
        });
        proc.stderr.on('data', (data) => {
          nativeLog += data;
        });
        await new Promise<void>((resolve, reject) => {
          const timer = setTimeout(() => {
            proc.kill('SIGKILL');
            reject(new Error('Native startup timeout'));
          }, 30000);
          proc.stdout.on('data', (data) => {
            nativeLog += data;
            spawnLog += data;
            if (spawnLog.includes('opencode server listening')) {
              clearTimeout(timer);
              resolve();
            }
          });
          proc.once('exit', (code) => {
            clearTimeout(timer);
            reject(new Error(`Native exit ${code}`));
          });
        });
        return { url: `http://127.0.0.1:${port}`, proc };
      },
      createClient: (url, cwd) => createOpencodeClient({ baseUrl: url, directory: cwd }) as any,
      createQuestionClient: (url) => createQuestionClient({ baseUrl: url }) as any,
    });
    try {
      const provider = new OpenCodeProvider({}, undefined, {
        executionPolicy: { '*': 'allow', question: 'deny' },
        mcpServers: {
          fixture: { type: 'local', command: [process.execPath, path.join(root, 'mcp-fixture.mjs')], enabled: true },
        },
        inference: {
          model: 'openai/fixture',
          small_model: 'openai/fixture',
          enabled_providers: ['openai'],
          provider: {
            openai: {
              npm: '@ai-sdk/openai-compatible',
              options: { baseURL: `http://127.0.0.1:${backend.port}/v1`, apiKey: 'fixture-placeholder' },
              models: {
                fixture: { id: 'fixture', name: 'fixture', tool_call: true, limit: { context: 20000, output: 1000 } },
              },
            },
          },
        },
      });
      provider.registerMemorySessionHook({
        command: `sh ${root}/hook.sh`,
        legacyCommands: [],
        sources: ['startup', 'compact'],
      });
      async function run(name: string, continuation?: string) {
        scenario = name;
        mainCalls = 0;
        const query = provider.query({
          prompt: `Run the ${name} fixture.`,
          cwd: path.join(root, 'workspace'),
          continuation,
          systemContext: { instructions: 'NATIVE_CORE_INSTRUCTIONS' },
        });
        query.end();
        const output: any[] = [];
        for await (const event of query.events) output.push(event);
        const final = output.find((event) => event.type === 'result');
        const result = final?.text;
        if (name === 'error') {
          assert.equal(final?.isError, true);
          assert.equal(result, null);
          assert.ok(
            output.some((event) => event.type === 'error' && event.message.includes('fixture authentication failed')),
          );
          assert.equal(output.filter((event) => event.type === 'result').length, 1);
          return output[0].continuation;
        }
        assert.ok(
          result?.includes(`NATIVE_${name.toUpperCase()}_PASS`),
          `Missing native result for ${name}: ${result}`,
        );
        assert.ok(!result?.includes('INTERNAL_COMPACTION_SUMMARY'));
        if (name === 'auto') assert.ok(result.includes('BEFORE_COMPACTION'), 'Lost the pre-compaction deliverable');
        console.log(
          JSON.stringify({
            scenario: name,
            continuation: output[0].continuation,
            result,
            requests: seen.filter((request) => request.scenario === name).length,
          }),
        );
        return output[0].continuation as string;
      }
      await run('basic');
      const autoSession = await run('auto');
      assert.equal(readFileSync(path.join(root, 'workspace/tool-proof'), 'utf8'), 'native-tool-proof');
      assert.ok(seen.some((request) => request.scenario === 'auto' && request.compact));
      const autoRequests = seen.filter((request) => request.scenario === 'auto' && !request.title && !request.compact);
      assert.ok(autoRequests.at(-1)?.memory.includes('NATIVE_MEMORY_SNAPSHOT'));
      assert.ok(!autoRequests.at(-1)?.memory.includes('MEMORY_AFTER_AUTO'), 'Compaction must use turn-start memory');
      assert.ok(!autoRequests[0].memory.includes('NATIVE_FILE_REREAD_PROOF'));
      assert.ok(
        autoRequests.at(-1)?.memory.includes('NATIVE_FILE_REREAD_PROOF'),
        'Native continuation cached the file',
      );
      assert.ok(autoRequests.at(-1)?.memory.includes('NATIVE_CORE_INSTRUCTIONS'));
      const startupCount = readFileSync(path.join(root, 'hook-events.log'), 'utf8').match(/startup/g)?.length;
      destroySharedRuntime();
      await run('resume', autoSession);
      assert.equal(
        readFileSync(path.join(root, 'hook-events.log'), 'utf8').match(/startup/g)?.length,
        (startupCount ?? 0) + 1,
      );
      assert.ok(
        seen
          .filter((request) => request.scenario === 'resume' && !request.title && !request.compact)
          .every((request) => request.memory.includes('MEMORY_AFTER_AUTO')),
      );
      await run('overflow');
      assert.ok(seen.some((request) => request.scenario === 'overflow' && request.compact));
      assert.ok(
        seen
          .filter((request) => request.scenario === 'overflow' && !request.title)
          .at(-1)
          ?.memory.includes('MEMORY_AFTER_AUTO'),
      );
      assert.ok(
        !seen
          .filter((request) => request.scenario === 'overflow' && !request.title && !request.compact)
          .at(-1)
          ?.memory.includes('MEMORY_AFTER_OVERFLOW'),
      );
      assert.ok(!readFileSync(path.join(root, 'hook-events.log'), 'utf8').includes('compact'));
      await run('child');
      assert.ok(
        seen.some(
          (request) =>
            request.scenario === 'child' &&
            request.body.messages.some(
              (message: any) =>
                message.role === 'tool' && JSON.stringify(message.content).includes('CHILD_WORK_COMPLETED'),
            ),
        ),
        'The child request must complete and return its result to the parent',
      );
      assert.ok(
        seen.some(
          (request) =>
            request.child &&
            request.memory.includes('MEMORY_AFTER_OVERFLOW') &&
            request.memory.includes('NATIVE_CORE_INSTRUCTIONS'),
        ),
      );
      await run('error');
      await run('mcp');
      assert.ok(
        seen.some((request) =>
          request.body.messages.some(
            (message: any) => message.role === 'tool' && JSON.stringify(message.content).includes('WAITED_65000'),
          ),
        ),
        'Native MCP timeout truncated a supported human/tool wait',
      );
      scenario = 'cancel';
      mainCalls = 0;
      const cancellation = provider.query({
        prompt: 'Start the cancellable MCP fixture.',
        cwd: path.join(root, 'workspace'),
      });
      cancellation.end();
      let cancelledSession: string | undefined;
      const spawnsBeforeCancel = spawnCount;
      const draining = (async () => {
        for await (const event of cancellation.events) {
          if (event.type === 'init') cancelledSession = event.continuation;
        }
      })();
      async function waitForFile(file: string, expected: string, timeoutMs = 15000) {
        const deadline = Date.now() + timeoutMs;
        while (Date.now() < deadline) {
          try {
            if (readFileSync(path.join(root, file), 'utf8') === expected) return;
          } catch {
            /* Not created yet. */
          }
          await Bun.sleep(25);
        }
        throw new Error(`Native fixture did not write ${file}=${expected}`);
      }
      await waitForFile('mcp-started', '300000');
      cancellation.abort();
      await draining;
      await waitForFile('mcp-aborted', '300000');
      assert.ok(cancelledSession);
      assert.equal(await run('after_cancel', cancelledSession), cancelledSession);
      assert.equal(spawnCount, spawnsBeforeCancel, 'Acknowledged cancellation should keep the shared server usable');
      console.log(
        JSON.stringify({
          success: true,
          root,
          requests: records.length,
          hooks: readFileSync(path.join(root, 'hook-events.log'), 'utf8'),
        }),
      );
    } finally {
      destroySharedRuntime();
      setSharedRuntimeDepsForTesting();
      backend.stop(true);
      resetAgentMailboxForTesting();
      closeSessionDb();
      if (composedFactory) registerAgentMailbox(composedFactory);
      if (savedDataHome === undefined) delete process.env.XDG_DATA_HOME;
      else process.env.XDG_DATA_HOME = savedDataHome;
      writeFileSync(path.join(root, 'requests.json'), JSON.stringify(seen, null, 2));
      writeFileSync(path.join(root, 'native.log'), nativeLog);
      console.log('Native evidence:', root);
    }
  },
  180000,
);

import { describe, it, expect } from 'bun:test';

import {
  autoAnswerQuestion,
  drainPendingQuestions,
  handleQuestionAsked,
  QUESTION_STEERING_TEXT,
  type QuestionClient,
} from './opencode.js';

/**
 * Fake `/v2` question client — captures every reply/list call so tests can
 * assert what OpenCodeProvider sends back without spawning a real server.
 * These unit tests check reply/list behavior for native request shapes.
 * opencode.shared-runtime.test.ts separately drives question.asked through
 * the production event pump and requires its reply before the turn completes.
 */
function createFakeQuestionClient(
  opts: {
    pending?: Array<{ id: string; sessionID?: string; questions?: unknown[] }>;
    replyError?: unknown;
  } = {},
): { client: QuestionClient; replyCalls: Array<{ requestID: string; answers: string[][] }> } {
  const replyCalls: Array<{ requestID: string; answers: string[][] }> = [];
  const client: QuestionClient = {
    question: {
      async reply(params) {
        replyCalls.push(params);
        if (opts.replyError) return { error: opts.replyError };
        return { data: true };
      },
      async list() {
        return { data: opts.pending ?? [] };
      },
    },
  };
  return { client, replyCalls };
}

describe('autoAnswerQuestion', () => {
  it('replies with one steering-text answer per sub-question — the wedge-path fix', async () => {
    const { client, replyCalls } = createFakeQuestionClient();

    // Simulates a `question.asked` event's properties for a two-part question.
    await autoAnswerQuestion(client, {
      id: 'que_f931faf310018jM9tBPKPMsezK',
      questions: [{ question: 'Proceed with deletion?' }, { question: 'Which target?' }],
    });

    expect(replyCalls).toEqual([
      {
        requestID: 'que_f931faf310018jM9tBPKPMsezK',
        answers: [[QUESTION_STEERING_TEXT], [QUESTION_STEERING_TEXT]],
      },
    ]);
  });

  it('answers with a single steering-text entry when the question count is unknown', async () => {
    const { client, replyCalls } = createFakeQuestionClient();

    await autoAnswerQuestion(client, { id: 'que_no_questions_array' });

    expect(replyCalls).toEqual([{ requestID: 'que_no_questions_array', answers: [[QUESTION_STEERING_TEXT]] }]);
  });

  it('steers the model toward autonomy or the real ask_user_question MCP tool', async () => {
    const { client, replyCalls } = createFakeQuestionClient();
    await autoAnswerQuestion(client, { id: 'que_1', questions: [{}] });
    const [{ answers }] = replyCalls;
    expect(answers[0][0]).toContain('ask_user_question');
    expect(answers[0][0].toLowerCase()).toContain('not available in this environment');
  });

  it('never throws — a failed reply must not take the session down with it', async () => {
    const { client } = createFakeQuestionClient({ replyError: { message: 'boom' } });
    await expect(autoAnswerQuestion(client, { id: 'que_err', questions: [{}] })).resolves.toBeUndefined();
  });

  it('is a no-op without a request id', async () => {
    const { client, replyCalls } = createFakeQuestionClient();
    await autoAnswerQuestion(client, {});
    expect(replyCalls).toEqual([]);
  });
});

describe('handleQuestionAsked', () => {
  it('answers a question.asked event whose sessionID differs from the active session', async () => {
    // This is the wedge fix: previously the `question.asked` case in
    // OpenCodeProvider's event loop skipped events where `req.sessionID` was
    // set and did not match the turn's own session. The server is shared, so
    // a skipped foreign-session question stayed wedged until the next
    // runtime creation ran drainPendingQuestions. handleQuestionAsked is what
    // that switch case now delegates to unconditionally — assert it answers
    // regardless of sessionID, simulating a question raised by some other,
    // unrelated session on the shared server.
    const { client, replyCalls } = createFakeQuestionClient();

    await handleQuestionAsked(client, {
      id: 'que_foreign_session',
      sessionID: 'ses_some_other_session',
      questions: [{}],
    });

    expect(replyCalls).toEqual([{ requestID: 'que_foreign_session', answers: [[QUESTION_STEERING_TEXT]] }]);
  });

  it('answers regardless of whether sessionID is present at all', async () => {
    const { client, replyCalls } = createFakeQuestionClient();
    await handleQuestionAsked(client, { id: 'que_no_session', questions: [{}] });
    expect(replyCalls.map((c) => c.requestID)).toEqual(['que_no_session']);
  });

  it('returns after its timeout and logs a never-resolving reply', async () => {
    // The event pump does not await this handler. Its own bounded wait
    // still reports a hung reply and returns without throwing. A short
    // budget avoids waiting out the real 10s production default.
    const client: QuestionClient = {
      question: {
        reply: () => new Promise(() => {}),
        list: async () => ({ data: [] }),
      },
    };

    const original = console.error;
    const messages: string[] = [];
    console.error = ((...args: unknown[]) => {
      messages.push(String(args[0]));
    }) as typeof console.error;

    try {
      await expect(handleQuestionAsked(client, { id: 'que_hung', questions: [{}] }, 20)).resolves.toBeUndefined();
    } finally {
      console.error = original;
    }

    expect(messages.some((m) => m.includes('Timed out') && m.includes('que_hung'))).toBe(true);
  });
});

describe('drainPendingQuestions', () => {
  it('answers every question already pending when the runtime starts', async () => {
    const { client, replyCalls } = createFakeQuestionClient({
      pending: [
        { id: 'que_a', sessionID: 'ses_1', questions: [{}] },
        { id: 'que_b', sessionID: 'ses_2', questions: [{}, {}] },
      ],
    });

    await drainPendingQuestions(client);

    expect(replyCalls.map((c) => c.requestID)).toEqual(['que_a', 'que_b']);
    expect(replyCalls[1].answers).toHaveLength(2);
  });

  it('does nothing when there are no pending questions', async () => {
    const { client, replyCalls } = createFakeQuestionClient({ pending: [] });
    await drainPendingQuestions(client);
    expect(replyCalls).toEqual([]);
  });

  it('never throws when listing itself fails', async () => {
    const client: QuestionClient = {
      question: {
        reply: async () => ({ data: true }),
        list: async () => {
          throw new Error('connection reset');
        },
      },
    };
    await expect(drainPendingQuestions(client)).resolves.toBeUndefined();
  });

  it('gives up after its timeout and logs, so a hung round-trip cannot block runtime startup', async () => {
    // The `.list()` call here never resolves — simulating a hung round-trip
    // to the OpenCode server. drainPendingQuestions is awaited inline in the
    // runtime-startup path, so it must return on its own timeout budget
    // rather than hang the caller forever. A short budget (well under bun
    // test's default timeout) keeps this deterministic and fast instead of
    // actually waiting out the real 10s production default.
    const client: QuestionClient = {
      question: {
        reply: async () => ({ data: true }),
        list: () => new Promise(() => {}),
      },
    };

    const original = console.error;
    const messages: string[] = [];
    console.error = ((...args: unknown[]) => {
      messages.push(String(args[0]));
    }) as typeof console.error;

    try {
      await expect(drainPendingQuestions(client, 20)).resolves.toBeUndefined();
    } finally {
      console.error = original;
    }

    expect(messages.some((m) => m.includes('Timed out') && m.includes('draining pending questions'))).toBe(true);
  });
});

import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
import type { ChildProcess } from 'child_process';
import { EventEmitter } from 'events';
import { mkdtempSync, rmSync } from 'fs';
import { tmpdir } from 'os';
import path from 'path';
import type { OpenCodeMessage, OpenCodeSessionClient } from './opencode-turn.js';
import type { OpenCodeMemorySessionHook } from './opencode-memory.js';

import {
  destroySharedRuntime,
  OpenCodeProvider,
  setSharedRuntimeDepsForTesting,
  type OpenCodeSharedRuntimeDeps,
  type QuestionClient,
} from './opencode.js';
import { initTestSessionDb, closeSessionDb, getInboundDb } from '../mailbox/sqlite/connection.js';
import { getUndeliveredMessages } from '../db/messages-out.js';
import { processQuery } from '../poll-loop.js';
import { registerAgentMailbox, resetAgentMailboxForTesting } from '../mailbox/index.js';
import { SqliteAgentMailbox } from '../mailbox/sqlite/index.js';
import { createProvider } from './factory.js';
import { registerProviderMemorySessionHook } from '../provider-contracts/realize.js';
import '../provider-contracts/index.js';
import type { ProviderEvent, ProviderExchange } from './types.js';

/**
 * The shared `opencode serve` lifecycle, driven through the
 * `setSharedRuntimeDepsForTesting` seam so no server process is ever spawned.
 *
 * Covers three review findings against the provider:
 *  - a failed or half-failed runtime init must never be cached, and a server
 *    that dies must drop out of the cache, so the next turn respawns it
 *    instead of every later message failing instantly with the same error;
 *  - `isSessionInvalid` must only fire on OpenCode's own session-not-found
 *    signal, never on backend/model errors, so a mistyped model id or a proxy
 *    hiccup does not wipe the stored conversation;
 *  - `abort()` stops one session and keeps the server; the in-turn watchdog
 *    treats the server's 10-second `server.heartbeat` as liveness.
 */

type Ev = { type: string; properties: Record<string, unknown> };

const MEMORY_HOOK: OpenCodeMemorySessionHook = {
  command: 'true',
  legacyCommands: [],
  sources: ['startup', 'compact'],
};

const CWD = '/tmp/opencode-shared-runtime-test';

function assistantReply(sessionID: string, text: string): Ev[] {
  return [
    { type: 'message.updated', properties: { info: { id: `msg_${text}`, role: 'assistant', sessionID } } },
    {
      type: 'message.part.updated',
      properties: { part: { type: 'text', messageID: `msg_${text}`, sessionID, text } },
    },
    { type: 'session.idle', properties: { sessionID } },
  ];
}

type FakeProc = ChildProcess & { kill: ReturnType<typeof mock>; emitExit(code: number): void };

/**
 * One fake server: a process handle whose `kill` ends the event stream (the
 * way SIGKILL drops a real SSE connection), plus a client whose `prompt`
 * hands the session id to the test so it decides what the server "emits".
 */
function fakeServer(onPrompt: (sessionId: string, promptIndex: number) => void) {
  const END = Symbol('end');
  const queue: Array<Ev | typeof END> = [{ type: 'server.connected', properties: {} }];
  const history = new Map<string, OpenCodeMessage[]>();
  let current:
    | { sessionId: string; userId: string; resolve(value: { data?: OpenCodeMessage; error?: unknown }): void }
    | undefined;
  let promptHandler = onPrompt;
  const finish = (error?: unknown) => {
    if (!current) return;
    let message = history
      .get(current.sessionId)!
      .findLast((m) => m.info.role === 'assistant' && m.info.parentID === current!.userId);
    if (error) {
      message = {
        info: {
          id: 'msg_error_' + current.userId,
          role: 'assistant',
          parentID: current.userId,
          time: { created: Date.now(), completed: Date.now() },
          error,
        },
        parts: [],
      };
      history.get(current.sessionId)!.push(message);
    }
    if (message) {
      current.resolve({ data: message });
      current = undefined;
    }
  };
  const waiters: Array<() => void> = [];
  const push = (events: Ev[]): void => {
    for (const event of events) {
      if (!current) continue;
      const rows = history.get(current.sessionId)!;
      const info = event.properties.info as (OpenCodeMessage['info'] & { sessionID?: string }) | undefined;
      if (event.type === 'message.updated' && info?.sessionID === current.sessionId && info.role === 'assistant') {
        rows.push({
          info: { ...info, parentID: current.userId, time: { created: Date.now(), completed: Date.now() } },
          parts: [],
        });
      }
      const part = event.properties.part as { type: string; text?: string; messageID: string } | undefined;
      if (event.type === 'message.part.updated' && part)
        rows.find((m) => m.info.id === part.messageID)?.parts.push({ ...part, id: 'prt_' + part.messageID });
    }
    queue.push(...events);
    while (waiters.length > 0 && queue.length > 0) waiters.shift()!();
  };
  const endStream = (): void => {
    queue.push(END);
    while (waiters.length > 0) waiters.shift()!();
  };
  async function* stream(): AsyncGenerator<Ev, void, void> {
    while (true) {
      if (queue.length === 0) await new Promise<void>((resolve) => waiters.push(resolve));
      const ev = queue.shift()!;
      if (ev === END) return;
      yield ev;
    }
  }

  const emitter = new EventEmitter();
  const proc = Object.assign(emitter, {
    pid: undefined,
    exitCode: null as number | null,
    signalCode: null,
    // Teardown marks the subscription released before killing its server.
    // The real SDK's onSseError then stops retries; model the closed stream.
    kill: mock(() => {
      endStream();
      return true;
    }),
    emitExit(code: number) {
      proc.exitCode = code;
      endStream();
      emitter.emit('exit', code, null);
    },
  }) as unknown as FakeProc;

  let sessionCount = 0;
  let promptCount = 0;
  // A live server answers an abort with that session's own error event.
  const abort = mock(async (params: { path: { id: string } }) => {
    push([
      {
        type: 'session.error',
        properties: {
          sessionID: params.path.id,
          error: { name: 'MessageAbortedError', data: { message: 'aborted' } },
        },
      },
    ]);
    finish({ name: 'MessageAbortedError', data: { message: 'aborted' } });
    return {};
  });
  const subscribe = mock(async (opts?: { signal?: AbortSignal }) => {
    opts?.signal?.addEventListener('abort', () => endStream(), { once: true });
    return { stream: stream() };
  });
  const client = {
    event: { subscribe },
    session: {
      async create() {
        sessionCount += 1;
        return { data: { id: `ses_${sessionCount}` } };
      },
      prompt: (async (params) => {
        promptCount += 1;
        const rows = history.get(params.path.id) ?? [];
        history.set(params.path.id, rows);
        rows.push({ info: { id: params.body.messageID, role: 'user', time: { created: Date.now() } }, parts: [] });
        return await new Promise((resolve) => {
          current = { sessionId: params.path.id, userId: params.body.messageID, resolve };
          promptHandler(params.path.id, promptCount);
        });
      }) as OpenCodeSessionClient['prompt'],
      messages: (async (params) => ({
        data: (history.get(params.path.id) ?? []).slice(-params.query.limit),
      })) as OpenCodeSessionClient['messages'],
      abort,
    },
  };
  const questionClient: QuestionClient = {
    question: {
      async reply() {
        return { data: true };
      },
      async list() {
        return { data: [] };
      },
    },
  };

  return {
    proc,
    client,
    questionClient,
    push,
    // Events and HTTP completion are independent. A stale idle/error event
    // cannot resolve the native prompt in this fixture any more than in production.
    finish,
    reply(sessionId: string, text: string) {
      push(assistantReply(sessionId, text));
      finish();
    },
    fail(sessionId: string, error: unknown) {
      push([{ type: 'session.error', properties: { sessionID: sessionId, error } }]);
      finish(error);
    },
    endStream,
    abort,
    subscribe,
    setPromptHandler: (handler: typeof onPrompt) => {
      promptHandler = handler;
    },
  };
}

function installDeps(servers: Array<ReturnType<typeof fakeServer>>, spawnFailures: Error[] = []) {
  let spawned = 0;
  let current: ReturnType<typeof fakeServer> | undefined;
  const spawnServer = mock(async (_configuration: Record<string, unknown>) => {
    const failure = spawnFailures.shift();
    if (failure) throw failure;
    current = servers[spawned];
    if (!current) throw new Error(`test: no fake server for spawn #${spawned + 1}`);
    spawned += 1;
    return { url: `http://127.0.0.1:0/${spawned}`, proc: current.proc };
  });
  const deps: OpenCodeSharedRuntimeDeps = {
    spawnServer,
    createClient: () => current!.client,
    createQuestionClient: () => current!.questionClient,
  };
  setSharedRuntimeDepsForTesting(deps);
  return { spawnServer };
}

function newProvider(): OpenCodeProvider {
  const provider = new OpenCodeProvider({});
  provider.registerMemorySessionHook(MEMORY_HOOK);
  return provider;
}

async function collect(events: AsyncIterable<ProviderEvent>): Promise<ProviderEvent[]> {
  const out: ProviderEvent[] = [];
  for await (const event of events) out.push(event);
  return out;
}

async function runOneTurn(provider: OpenCodeProvider, continuation?: string): Promise<ProviderEvent[]> {
  const query = provider.query({ prompt: 'hi', cwd: CWD, continuation });
  query.end();
  return collect(query.events);
}

const resultText = (events: ProviderEvent[]) =>
  events.filter((e) => e.type === 'result').map((e) => (e as { text: string | null }).text);

let composedFactory: ReturnType<typeof resetAgentMailboxForTesting>;
let memoryDir: string;
let savedXdg: string | undefined;
beforeEach(() => {
  composedFactory = resetAgentMailboxForTesting();
  initTestSessionDb();
  registerAgentMailbox(() => new SqliteAgentMailbox());
  savedXdg = process.env.XDG_DATA_HOME;
  memoryDir = mkdtempSync(path.join(tmpdir(), 'opencode-runtime-memory-'));
  process.env.XDG_DATA_HOME = memoryDir;
  destroySharedRuntime();
});
afterEach(() => {
  destroySharedRuntime();
  setSharedRuntimeDepsForTesting(undefined);
  if (savedXdg === undefined) delete process.env.XDG_DATA_HOME;
  else process.env.XDG_DATA_HOME = savedXdg;
  resetAgentMailboxForTesting();
  closeSessionDb();
  if (composedFactory) registerAgentMailbox(composedFactory);
  rmSync(memoryDir, { recursive: true, force: true });
});

describe('shared runtime recovery', () => {
  it('routes question.asked through the production event pump before native work continues', async () => {
    let sessionId = '';
    const replies: Array<{ requestID: string; answers: string[][] }> = [];
    const server = fakeServer((sid) => {
      sessionId = sid;
      server.push([
        { type: 'question.asked', properties: { id: 'que_fixture', sessionID: 'ses_other', questions: [{}] } },
      ]);
    });
    server.questionClient.question.reply = async (params) => {
      replies.push(params);
      server.reply(sessionId, 'continued after steering');
      return { data: true };
    };
    installDeps([server]);
    const query = newProvider().query({ prompt: 'work', cwd: CWD });
    query.end();
    // A missing routing branch must fail promptly rather than waiting for
    // the production idle watchdog.
    const timer = setTimeout(() => query.abort(), 1000);
    try {
      expect(resultText(await collect(query.events))).toEqual(['continued after steering']);
      expect(replies).toHaveLength(1);
      expect(replies[0].requestID).toBe('que_fixture');
      expect(replies[0].answers[0][0]).toContain('ask_user_question');
      expect(server.abort).not.toHaveBeenCalled();
    } finally {
      clearTimeout(timer);
      query.abort();
    }
  });

  for (const partial of [false, true]) {
    it(`completes a native error once without a retry, with prior text: ${partial}`, async () => {
      getInboundDb()
        .prepare(
          `INSERT INTO destinations (name, display_name, type, channel_type, platform_id, agent_group_id)
         VALUES ('main', 'main', 'channel', 'discord', 'chan-1', NULL)`,
        )
        .run();
      const server = fakeServer((sid) => {
        if (partial) server.push(assistantReply(sid, '<message to="main">Completed before failure.</message>'));
        server.fail(sid, {
          name: 'APIError',
          data: {
            message: 'backend failed',
            isRetryable: false,
            responseBody: '<message to="main">RAW_DIAGNOSTIC_MUST_NOT_DELIVER</message>',
            responseHeaders: { 'x-fixture': 'RAW_HEADER' },
          },
        });
      });
      installDeps([server]);
      const query = newProvider().query({ prompt: 'work', cwd: CWD });
      query.push = mock(query.push);
      query.end();
      const exchanges: ProviderExchange[] = [];
      await processQuery(
        query,
        { platformId: 'chan-1', channelType: 'discord', threadId: null, inReplyTo: 'm1', taskRun: false },
        ['m1'],
        'opencode',
        (exchange) => exchanges.push(exchange),
        'work',
        undefined,
      );
      expect(exchanges).toHaveLength(1);
      expect(exchanges[0].result ?? '').not.toContain('backend failed');
      expect(exchanges[0].result ?? '').not.toContain('RAW_DIAGNOSTIC_MUST_NOT_DELIVER');
      const sent = getUndeliveredMessages()
        .filter((row) => row.kind === 'chat')
        .map((row) => (JSON.parse(row.content) as { text: string }).text);
      expect(sent).toEqual([
        ...(partial ? ['Completed before failure.'] : []),
        'The agent run failed. Check the logs for details.',
      ]);
      if (partial) expect(exchanges[0].result).toContain('Completed before failure.');
      expect(exchanges[0].status).toBe('error');
      expect(query.push).not.toHaveBeenCalled();
      expect(server.abort).not.toHaveBeenCalled();
    });
  }

  it('retries the spawn on the next query instead of caching the rejection', async () => {
    const server = fakeServer((sid) => server.reply(sid, 'back'));
    const { spawnServer } = installDeps([server], [new Error('Timeout waiting for OpenCode server to start')]);
    const provider = newProvider();

    await expect(runOneTurn(provider)).rejects.toThrow('Timeout waiting for OpenCode server');
    expect(resultText(await runOneTurn(provider))).toEqual(['back']);
    expect(spawnServer).toHaveBeenCalledTimes(2);
  });

  it('kills a server whose client setup fails after the spawn, and respawns next time', async () => {
    const broken = fakeServer(() => {});
    broken.subscribe.mockImplementationOnce(async () => {
      throw new Error('subscribe exploded');
    });
    const healthy = fakeServer((sid) => healthy.reply(sid, 'ok'));
    const { spawnServer } = installDeps([broken, healthy]);
    const provider = newProvider();

    await expect(runOneTurn(provider)).rejects.toThrow('subscribe exploded');
    expect(broken.proc.kill).toHaveBeenCalledTimes(1);

    expect(resultText(await runOneTurn(provider))).toEqual(['ok']);
    expect(spawnServer).toHaveBeenCalledTimes(2);
  });

  it('respawns after the server process exits between turns', async () => {
    const first = fakeServer((sid) => first.reply(sid, 'one'));
    const second = fakeServer((sid) => second.reply(sid, 'two'));
    const { spawnServer } = installDeps([first, second]);
    const provider = newProvider();

    expect(resultText(await runOneTurn(provider))).toEqual(['one']);
    first.proc.emitExit(137);

    expect(resultText(await runOneTurn(provider))).toEqual(['two']);
    expect(spawnServer).toHaveBeenCalledTimes(2);
  });

  it('server exit mid-turn fails the in-flight query promptly, keeps the continuation, and respawns', async () => {
    const dying = fakeServer(() => {
      // Prompt accepted, then the server is SIGKILLed before any event.
      setTimeout(() => dying.proc.emitExit(137), 20);
    });
    const healthy = fakeServer((sid) => healthy.reply(sid, 'ok'));
    const { spawnServer } = installDeps([dying, healthy]);
    const provider = newProvider();

    let thrown: unknown;
    const started = Date.now();
    await runOneTurn(provider, 'ses_kept').catch((err: unknown) => {
      thrown = err;
    });
    expect((thrown as Error).message).toContain('OpenCode event stream ended unexpectedly');
    expect(Date.now() - started).toBeLessThan(2000);
    // The session on disk is intact: a dead server is not a stale session.
    expect(provider.isSessionInvalid(thrown)).toBe(false);
    // The subscription was opened with an abort signal and it was aborted.
    expect(dying.subscribe.mock.calls[0][0]?.signal?.aborted).toBe(true);
    // No retry cap: the SDK counts attempts cumulatively per subscription, so
    // a cap would end a long-lived stream on the Nth transient hiccup.
    expect((dying.subscribe.mock.calls[0][0] as { sseMaxRetryAttempts?: number })?.sseMaxRetryAttempts).toBeUndefined();

    expect(resultText(await runOneTurn(provider))).toEqual(['ok']);
    expect(spawnServer).toHaveBeenCalledTimes(2);
  });

  it('drops the runtime when the event stream ends mid-turn so the next query respawns', async () => {
    const dying = fakeServer(() => dying.endStream());
    const healthy = fakeServer((sid) => healthy.reply(sid, 'ok'));
    const { spawnServer } = installDeps([dying, healthy]);
    const provider = newProvider();

    await expect(runOneTurn(provider)).rejects.toThrow('OpenCode event stream ended unexpectedly');
    expect(dying.proc.kill).toHaveBeenCalledTimes(1);

    expect(resultText(await runOneTurn(provider))).toEqual(['ok']);
    expect(spawnServer).toHaveBeenCalledTimes(2);
  });

  it('reuses one server across queries when nothing went wrong', async () => {
    const server = fakeServer((sid, n) => server.reply(sid, `r${n}`));
    const { spawnServer } = installDeps([server]);
    const provider = newProvider();

    expect(resultText(await runOneTurn(provider))).toEqual(['r1']);
    expect(resultText(await runOneTurn(provider, 'ses_1'))).toEqual(['r2']);
    expect(spawnServer).toHaveBeenCalledTimes(1);
    expect(server.proc.kill).not.toHaveBeenCalled();
  });

  it('does not finish a native prompt when its event stream reports idle or a recoverable error', async () => {
    let sessionId = '';
    const server = fakeServer((sid) => {
      sessionId = sid;
    });
    installDeps([server]);
    let settled = false;
    const result = runOneTurn(newProvider()).finally(() => {
      settled = true;
    });
    while (!sessionId) await Bun.sleep(1);
    server.push(assistantReply(sessionId, 'verified text'));
    server.push([
      { type: 'session.error', properties: { sessionID: sessionId, error: { name: 'ContextOverflowError' } } },
    ]);
    await Bun.sleep(10);
    expect(settled).toBe(false);
    server.finish();
    expect(resultText(await result)).toEqual(['verified text']);
    expect(server.abort).not.toHaveBeenCalled();
  });
});

describe('isSessionInvalid', () => {
  const provider = newProvider();

  it("fires only on OpenCode's own NotFoundError for the session", () => {
    expect(
      provider.isSessionInvalid(
        new Error('OpenCode prompt: {"name":"NotFoundError","data":{"message":"Session not found: ses_gone"}}'),
      ),
    ).toBe(true);
  });

  it('keeps the continuation on backend, proxy and watchdog errors', () => {
    for (const msg of [
      '404 No endpoints found',
      'OpenCode retry limit (3): 404 No endpoints found',
      'read ECONNRESET',
      'connection reset by peer',
      'OpenCode event stream silent for 60000ms; server dropped',
      'OpenCode turn produced no activity for 900000ms; aborted',
      'OpenCode SSE stream ended unexpectedly',
      'OpenCode prompt: {}',
    ]) {
      expect(provider.isSessionInvalid(new Error(msg))).toBe(false);
    }
  });

  it('a backend 404 surfaced as session.error is a turn error, not a stale session', async () => {
    const server = fakeServer((sid) =>
      server.fail(sid, { name: 'APIError', data: { message: '404 No endpoints found' } }),
    );
    installDeps([server]);
    const provider = newProvider();

    const result = (await runOneTurn(provider, 'ses_1')).find((event) => event.type === 'result');
    expect(result?.isError).toBe(true);
    expect(result?.text).toBeNull();
    expect(provider.isSessionInvalid(new Error('404 No endpoints found'))).toBe(false);
  });

  it.each(['APIError', 'ProviderAuthError'])(
    'an authentication failure (%s) preserves the resumable session contract',
    async (name) => {
      const server = fakeServer((sid) =>
        server.fail(sid, { name, data: { statusCode: 401, message: 'Authentication failed' } }),
      );
      installDeps([server]);
      const provider = newProvider();
      const result = (await runOneTurn(provider, 'ses_1')).find((event) => event.type === 'result');
      expect(result?.isError).toBe(true);
      expect(result?.text).toBeNull();
      expect(provider.isSessionInvalid(new Error('Authentication failed'))).toBe(false);
    },
  );

  it('a prompt NotFoundError for the resumed id is a stale session', async () => {
    const server = fakeServer(() => {});
    server.client.session.prompt = async () => ({
      error: { name: 'NotFoundError', data: { message: 'Session not found: ses_gone' } },
    });
    installDeps([server]);
    const provider = newProvider();

    let thrown: unknown;
    await runOneTurn(provider, 'ses_gone').catch((err: unknown) => {
      thrown = err;
    });
    expect(provider.isSessionInvalid(thrown)).toBe(true);
  });
});

describe('abort and watchdog', () => {
  it('suppresses a runtime startup error after the query was aborted', async () => {
    let rejectRuntime!: (error: Error) => void;
    const provider = new OpenCodeProvider(
      {},
      {
        getRuntime: () =>
          new Promise((_, reject) => {
            rejectRuntime = reject;
          }),
      },
    );
    provider.registerMemorySessionHook(MEMORY_HOOK);
    const query = provider.query({ prompt: 'work', cwd: CWD });
    const first = query.events[Symbol.asyncIterator]().next();

    query.abort();
    rejectRuntime(new Error('server startup failed'));

    await expect(first).resolves.toEqual({ done: true, value: undefined });
  });

  it('abort() stops the in-flight session and keeps the shared server', async () => {
    const server = fakeServer(() => {});
    const { spawnServer } = installDeps([server]);
    const provider = newProvider();

    const query = provider.query({ prompt: 'work', cwd: CWD });
    const iterator = query.events[Symbol.asyncIterator]();
    expect((await iterator.next()).value).toEqual({ type: 'init', continuation: 'ses_1' });

    // The generator is now parked on stream.next() with a prompt in flight.
    const pendingNext = iterator.next();
    await Bun.sleep(10);
    query.abort();

    // What the server sends back for the aborted session (the fake abort
    // emits it) must not become this query's error.
    expect((await pendingNext).done).toBe(true);
    expect(server.abort).toHaveBeenCalledTimes(1);
    expect(server.abort.mock.calls[0][0]).toMatchObject({ path: { id: 'ses_1' } });
    expect(server.proc.kill).not.toHaveBeenCalled();

    // The next query lands on the same server.
    const again = provider.query({ prompt: 'again', cwd: CWD });
    again.end();
    const promptedOn: string[] = [];
    server.setPromptHandler((sid) => {
      promptedOn.push(sid);
      server.reply(sid, 'fresh');
    });
    expect(resultText(await collect(again.events))).toEqual(['fresh']);
    expect(promptedOn).toEqual(['ses_2']);
    expect(spawnServer).toHaveBeenCalledTimes(1);
  });

  it('abort() while parked in session.create() sends no prompt', async () => {
    const server = fakeServer(() => {});
    let releaseCreate: (() => void) | undefined;
    const realCreate = server.client.session.create;
    server.client.session.create = async () => {
      await new Promise<void>((resolve) => {
        releaseCreate = resolve;
      });
      return realCreate();
    };
    const prompt = mock(server.client.session.prompt);
    server.client.session.prompt = prompt;
    installDeps([server]);
    const provider = newProvider();

    const query = provider.query({ prompt: 'work', cwd: CWD });
    const iterator = query.events[Symbol.asyncIterator]();
    const first = iterator.next();
    while (!releaseCreate) await new Promise((r) => setTimeout(r, 1));

    query.abort();
    releaseCreate();
    expect((await first).done).toBe(true);

    expect(prompt).not.toHaveBeenCalled();
    expect(server.abort).not.toHaveBeenCalled();
  });

  describe('with short watchdog budgets', () => {
    const saved: Record<string, string | undefined> = {};
    const KEYS = ['OPENCODE_IDLE_TIMEOUT_MS', 'OPENCODE_STREAM_SILENCE_MS'] as const;
    beforeEach(() => {
      for (const k of KEYS) saved[k] = process.env[k];
    });
    afterEach(() => {
      for (const k of KEYS) {
        if (saved[k] === undefined) delete process.env[k];
        else process.env[k] = saved[k];
      }
    });

    it('stream tier: heartbeats keep a quiet tool run alive; only agent events count as activity', async () => {
      process.env.OPENCODE_STREAM_SILENCE_MS = '150';
      process.env.OPENCODE_IDLE_TIMEOUT_MS = '10000';
      const server = fakeServer((sid) => {
        // A tool that streams nothing for well over the silence budget while
        // the server's heartbeat keeps ticking, then the reply.
        let ticks = 0;
        const beat = setInterval(() => {
          server.push([{ type: 'server.heartbeat', properties: {} }]);
          ticks += 1;
          if (ticks >= 12) {
            clearInterval(beat);
            server.reply(sid, 'done after a long tool');
          }
        }, 40);
      });
      installDeps([server]);
      const provider = newProvider();

      const events = await runOneTurn(provider);
      expect(resultText(events)).toEqual(['done after a long tool']);
      expect(server.proc.kill).not.toHaveBeenCalled();
      expect(server.abort).not.toHaveBeenCalled();
      expect(events.filter((e) => e.type === 'activity').length).toBeLessThanOrEqual(2);
    });

    it('stream tier: silence including heartbeats drops the server as genuine death', async () => {
      process.env.OPENCODE_STREAM_SILENCE_MS = '150';
      process.env.OPENCODE_IDLE_TIMEOUT_MS = '10000';
      const server = fakeServer(() => {});
      installDeps([server]);
      const provider = newProvider();

      await expect(runOneTurn(provider)).rejects.toThrow('OpenCode event stream silent for 150ms');
      expect(server.proc.kill).toHaveBeenCalledTimes(1);
      expect(server.abort).toHaveBeenCalledTimes(1);
    });

    it('activity tier: a wedged backend on a live stream aborts the session and keeps the server', async () => {
      process.env.OPENCODE_STREAM_SILENCE_MS = '10000';
      process.env.OPENCODE_IDLE_TIMEOUT_MS = '150';
      const server = fakeServer(() => {
        const beat = setInterval(() => server.push([{ type: 'server.heartbeat', properties: {} }]), 40);
        setTimeout(() => clearInterval(beat), 2000);
      });
      const { spawnServer } = installDeps([server]);
      const provider = newProvider();

      await expect(runOneTurn(provider)).rejects.toThrow('OpenCode turn produced no activity for 150ms; aborted');
      expect(server.abort).toHaveBeenCalledTimes(1);
      expect(server.abort.mock.calls[0][0]).toMatchObject({ path: { id: 'ses_1' } });
      expect(server.proc.kill).not.toHaveBeenCalled();
      // A backend wedge is not a stale session: the continuation must survive.
      expect(provider.isSessionInvalid(new Error('OpenCode turn produced no activity for 150ms; aborted'))).toBe(false);

      // The server is still the one we had.
      server.setPromptHandler((sid) => server.reply(sid, 'recovered'));
      expect(resultText(await runOneTurn(provider))).toEqual(['recovered']);
      expect(spawnServer).toHaveBeenCalledTimes(1);
    });
  });
});

describe('SDK stream cleanup', () => {
  it('handles an asynchronous AbortError from the stream return operation', async () => {
    const server = fakeServer((sid) => server.reply(sid, 'done'));
    const subscribe = server.subscribe.getMockImplementation()!;
    const returnStream = mock(async () => {
      throw new DOMException('Aborted', 'AbortError');
    });
    server.subscribe.mockImplementationOnce(async (options) => {
      const subscription = await subscribe(options);
      subscription.stream.return = returnStream;
      return subscription;
    });
    installDeps([server]);
    await runOneTurn(newProvider());
    destroySharedRuntime();
    await Bun.sleep(0);
    expect(returnStream).toHaveBeenCalled();
  });
});

describe('runtime contract consumption', () => {
  it('uses the core-resolved configuration even if environment defaults change before query', async () => {
    const server = fakeServer((sid) => server.reply(sid, 'configured'));
    const { spawnServer } = installDeps([server]);
    const saved = { ...process.env };
    try {
      process.env.OPENCODE_PROVIDER = 'openai';
      process.env.OPENCODE_MODEL = 'openai/default';
      process.env.ANTHROPIC_BASE_URL = 'http://localhost:8891/v1';
      const provider = createProvider('opencode', { model: 'openai/group-model', effort: 'high' });
      registerProviderMemorySessionHook('opencode', provider, MEMORY_HOOK);
      process.env.OPENCODE_PROVIDER = 'anthropic';
      process.env.OPENCODE_MODEL = 'changed-after-resolution';
      await runOneTurn(provider as OpenCodeProvider);
      expect(spawnServer.mock.calls[0][0]).toMatchObject({
        model: 'openai/group-model',
        enabled_providers: ['openai'],
        permission: { question: 'deny', bash: 'allow' },
        provider: { openai: { models: { 'group-model': { options: { reasoningEffort: 'high' } } } } },
      });
    } finally {
      for (const key of Object.keys(process.env)) if (!(key in saved)) delete process.env[key];
      Object.assign(process.env, saved);
    }
  });

  it('restarts the shared server when effective effort changes', async () => {
    const first = fakeServer((sid) => first.reply(sid, 'one'));
    const second = fakeServer((sid) => second.reply(sid, 'two'));
    const { spawnServer } = installDeps([first, second]);
    const config = (effort: string) => ({
      executionPolicy: { question: 'deny' },
      inference: { model: 'openai/test', provider: { openai: { options: { reasoningEffort: effort } } } },
      mcpServers: {},
    });
    for (const effort of ['low', 'high']) {
      const provider = new OpenCodeProvider({}, undefined, config(effort));
      provider.registerMemorySessionHook(MEMORY_HOOK);
      await runOneTurn(provider);
    }
    expect(spawnServer).toHaveBeenCalledTimes(2);
    expect(first.proc.kill).toHaveBeenCalled();
  });
});

import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
import type { ChildProcess } from 'node:child_process';
import { EventEmitter } from 'node:events';
import { createServer, type ServerResponse } from 'node:http';
import { mkdtempSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { initTestSessionDb, closeSessionDb } from '../mailbox/sqlite/connection.js';
import { registerAgentMailbox, resetAgentMailboxForTesting } from '../mailbox/index.js';
import { SqliteAgentMailbox } from '../mailbox/sqlite/index.js';
import type { OpenCodeMessage } from './opencode-turn.js';
import { createOpencodeClient } from '@opencode-ai/sdk';
import {
  destroySharedRuntime,
  OpenCodeProvider,
  setSharedRuntimeDepsForTesting,
  type SseSubscribeOptions,
} from './opencode.js';

let directory: string;
let previousXdg: string | undefined;
let previousMailbox: ReturnType<typeof resetAgentMailboxForTesting>;
beforeEach(() => {
  directory = mkdtempSync(path.join(tmpdir(), 'opencode-sse-'));
  previousXdg = process.env.XDG_DATA_HOME;
  process.env.XDG_DATA_HOME = directory;
  previousMailbox = resetAgentMailboxForTesting();
  initTestSessionDb();
  registerAgentMailbox(() => new SqliteAgentMailbox());
});
afterEach(() => {
  destroySharedRuntime();
  setSharedRuntimeDepsForTesting();
  if (previousXdg === undefined) delete process.env.XDG_DATA_HOME;
  else process.env.XDG_DATA_HOME = previousXdg;
  resetAgentMailboxForTesting();
  closeSessionDb();
  if (previousMailbox) registerAgentMailbox(previousMailbox);
  rmSync(directory, { recursive: true, force: true });
});

// Exercise the pinned generated SDK, whose reader.cancel() abort rejection is
// invisible to the provider's fake event streams. No global rejection handler.
describe('real SDK event-stream teardown', () => {
  for (const phase of ['yield', 'read', 'backoff'] as const) {
    it(`releases during ${phase} without unhandled rejection or retry`, async () => {
      let response: ServerResponse | undefined;
      let requests = 0;
      let signalPrompt!: () => void;
      const prompted = new Promise<void>((resolve) => {
        signalPrompt = resolve;
      });
      let signalSleep!: () => void;
      const sleeping = new Promise<void>((resolve) => {
        signalSleep = resolve;
      });
      const send = (value: unknown) => response!.write(`data: ${JSON.stringify(value)}\n\n`);
      const server = createServer((_req, res) => {
        requests++;
        response = res;
        res.writeHead(200, { 'content-type': 'text/event-stream' });
        send({ type: 'server.connected', properties: {} });
        if (phase === 'yield') {
          send({ type: 'session.idle', properties: { sessionID: 'ses_fixture' } });
        } else if (phase === 'backoff') {
          setTimeout(() => res.destroy(), 5);
        }
      });
      await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
      const address = server.address() as { port: number };
      const url = `http://127.0.0.1:${address.port}`;
      const sdk = createOpencodeClient({ baseUrl: url });
      const proc = Object.assign(new EventEmitter(), {
        pid: undefined,
        exitCode: null,
        signalCode: null,
        kill: () => {
          server.closeAllConnections();
          return true;
        },
      }) as unknown as ChildProcess;
      const history: OpenCodeMessage[] = [];
      let finishPrompt: ((result: { error: unknown }) => void) | undefined;
      setSharedRuntimeDepsForTesting({
        spawnServer: async () => ({ url, proc }),
        createClient: () => ({
          session: {
            create: async () => ({ data: { id: 'ses_fixture' } }),
            messages: async () => ({ data: history }),
            abort: async () => {
              finishPrompt?.({ error: { name: 'MessageAbortedError' } });
              return {};
            },
            prompt: async (params) => {
              history.push({
                info: { id: params.body.messageID, role: 'user', time: { created: Date.now() } },
                parts: [],
              });
              signalPrompt();
              if (phase !== 'yield')
                return await new Promise((resolve) => {
                  finishPrompt = resolve;
                });
              const answer: OpenCodeMessage = {
                info: {
                  id: 'msg_answer',
                  role: 'assistant',
                  parentID: params.body.messageID,
                  time: { created: Date.now() },
                },
                parts: [{ id: 'prt_answer', type: 'text', text: 'done' }],
              };
              history.push(answer);
              return { data: answer };
            },
          },
          event: {
            subscribe: (options?: SseSubscribeOptions) =>
              sdk.event.subscribe({
                ...options,
                sseSleepFn: async () => {
                  signalSleep();
                  await options!.sseSleepFn!(30_000);
                },
              }),
          },
        }),
        createQuestionClient: () => ({
          question: { reply: async () => ({ data: true }), list: async () => ({ data: [] }) },
        }),
      });
      try {
        const provider = new OpenCodeProvider();
        provider.registerMemorySessionHook({ command: 'true', legacyCommands: [], sources: [] });
        const query = provider.query({ prompt: 'test', cwd: '/tmp' });
        query.end();
        const collected = (async () => {
          for await (const _event of query.events) {
          }
        })();
        // Attach a rejection handler before provoking the expected termination.
        const settled = collected.then(
          () => 'finished',
          () => 'stream-ended',
        );
        await prompted;
        if (phase === 'yield') await collected;
        else if (phase === 'backoff') await sleeping;
        else while (!response) await Bun.sleep(1);
        destroySharedRuntime();
        let timeout: ReturnType<typeof setTimeout>;
        try {
          await Promise.race([
            settled,
            new Promise((_, reject) => {
              timeout = setTimeout(() => reject(new Error('teardown did not wake stream')), 1000);
            }),
          ]);
        } finally {
          clearTimeout(timeout!);
        }
        await Bun.sleep(10);
        expect(requests).toBe(1);
      } finally {
        destroySharedRuntime();
        server.closeAllConnections();
        server.close();
      }
    });
  }
});

import { initializeOpenCodeAuth } from './opencode-auth.js';
import { spawn, type ChildProcess } from 'child_process';
import { lstatSync, realpathSync } from 'fs';
import path from 'path';
import { pathToFileURL } from 'url';

import { createOpencodeClient, type FilePartInput } from '@opencode-ai/sdk';
// The root client has no `.question` surface; reply/reject/list for the
// interactive `question` tool live on the `/v2` subpath client. Import it
// separately so the session/event client above is untouched.
import { createOpencodeClient as createOpencodeQuestionClient } from '@opencode-ai/sdk/v2';

import { registerProvider } from './provider-registry.js';
import type { AgentProvider, AgentQuery, ProviderEvent, ProviderOptions, QueryInput } from './types.js';
import {
  buildOpenCodeConfig,
  buildOpenCodeServerEnv,
  resolveOpenCodeInference,
  resolveOpenCodePromptModel,
} from './opencode-config.js';
import { buildDeliverySentences } from '../compact-instructions.js';
import type { ResolvedRuntimeConfiguration } from '../provider-contracts/registry.js';
import { getTaskSeriesId } from '../db/session-routing.js';
import { getAllDestinations } from '../destinations.js';
import { prepareOpenCodeMemory, type OpenCodeMemorySessionHook } from './opencode-memory.js';
import {
  boundedOpenCodeCall,
  executeOpenCodeTurn,
  OpenCodeEventPump,
  type OpenCodeSessionClient,
} from './opencode-turn.js';

function log(msg: string): void {
  console.error(`[opencode-provider] ${msg}`);
}

/**
 * In-turn watchdog defaults (see the two tiers in `query()`). Env overrides:
 * `OPENCODE_STREAM_SILENCE_MS` and `OPENCODE_IDLE_TIMEOUT_MS`. The server
 * heartbeats every 10 s, so 60 s of total silence is six missed beats; the
 * activity budget is generous because a single tool call (a long build, a
 * browser session) legitimately streams nothing for many minutes.
 */
const DEFAULT_STREAM_SILENCE_MS = 60_000;
const DEFAULT_IDLE_TIMEOUT_MS = 900_000;

const AGENT_DIR = '/workspace/agent';
const DEFAULT_NATIVE_ATTACHMENT_MAX_COUNT = 8;
const DEFAULT_NATIVE_ATTACHMENT_MAX_BYTES = 25 * 1024 * 1024;

/** Native session lookup errors invalidate a stored continuation; backend/network failures do not. */
const STALE_SESSION_RE = /"name":"NotFoundError"/;

function killProcessTree(proc: ChildProcess): void {
  if (proc.pid) {
    try {
      process.kill(-proc.pid, 'SIGKILL');
      return;
    } catch {
      /* fall through to the single-process kill */
    }
  }
  // No pid (spawn never produced one) or the group signal failed: best-effort
  // on the handle itself. A ChildProcess without a pid returns false here.
  try {
    proc.kill('SIGKILL');
  } catch {
    /* ignore */
  }
}

export function spawnOpencodeServer(
  config: Record<string, unknown>,
  timeoutMs = 10_000,
): Promise<{ url: string; proc: ChildProcess }> {
  return new Promise((resolve, reject) => {
    initializeOpenCodeAuth(process.env.XDG_DATA_HOME ?? '/opencode-xdg', process.env.OPENCODE_AUTH_MODE);
    const hostname = '127.0.0.1';
    const port = 4096;
    const proc = spawn('opencode', ['serve', `--hostname=${hostname}`, `--port=${port}`], {
      // `opencode serve` has no directory flag. Its cwd is the project root
      // used by native document discovery and built-in filesystem tools.
      cwd: AGENT_DIR,
      env: buildOpenCodeServerEnv(config),
      detached: true,
    });

    const id = setTimeout(() => {
      killProcessTree(proc);
      reject(new Error(`Timeout waiting for OpenCode server to start after ${timeoutMs}ms`));
    }, timeoutMs);

    let output = '';
    proc.stdout?.on('data', (chunk: Buffer) => {
      output += chunk.toString();
      for (const line of output.split('\n')) {
        if (line.startsWith('opencode server listening')) {
          const match = line.match(/on\s+(https?:\/\/[^\s]+)/);
          if (match) {
            clearTimeout(id);
            resolve({ url: match[1], proc });
          }
        }
      }
    });
    proc.stderr?.on('data', (chunk: Buffer) => {
      output += chunk.toString();
    });
    proc.on('exit', (code) => {
      clearTimeout(id);
      let msg = `OpenCode server exited with code ${code}`;
      if (output.trim()) msg += `\nServer output: ${output}`;
      reject(new Error(msg));
    });
    proc.on('error', (err) => {
      clearTimeout(id);
      reject(err);
    });
  });
}

/**
 * The shared attachment contract carries only host-staged files, bound to the
 * source message whose inbox owns them. Remote URLs remain prompt text and are
 * never fetched implicitly.
 *
 * Attachments are ALSO described inline in the prompt text the formatter
 * produces, and that text rendering stays the contract every provider relies
 * on. Everything below is an additive view for OpenCode's file parts: when no
 * structured attachment arrives, the provider behaves exactly as it did before.
 */
interface OpenCodePromptAttachment {
  sourceMessageId: string;
  filename: string;
  path: string;
  mime?: string;
}

/** Extension → MIME fallback, for adapters that report no `mimeType`. */
const ATTACHMENT_MIME_BY_EXT: Record<string, string> = {
  '.png': 'image/png',
  '.jpg': 'image/jpeg',
  '.jpeg': 'image/jpeg',
  '.gif': 'image/gif',
  '.webp': 'image/webp',
  '.heic': 'image/heic',
  '.pdf': 'application/pdf',
};

function attachmentMime(att: OpenCodePromptAttachment): string | undefined {
  if (att.mime) return att.mime;
  const name = att.path || att.filename || '';
  const dot = name.lastIndexOf('.');
  return dot < 0 ? undefined : ATTACHMENT_MIME_BY_EXT[name.slice(dot).toLowerCase()];
}

export interface NativeAttachmentLimits {
  maxCount: number;
  maxBytes: number;
}

export interface NativeAttachmentFileInfo {
  realPath: string;
  size: number;
}

function positiveIntegerEnv(name: string, fallback: number): number {
  const raw = process.env[name];
  if (raw === undefined) return fallback;
  const trimmed = raw.trim();
  const parsed = Number(trimmed);
  if (!/^\d+$/.test(trimmed) || !Number.isSafeInteger(parsed) || parsed <= 0) {
    log(`Ignoring invalid ${name}: "${raw}"`);
    return fallback;
  }
  return parsed;
}

export function resolveNativeAttachmentLimits(): NativeAttachmentLimits {
  return {
    maxCount: positiveIntegerEnv('OPENCODE_NATIVE_ATTACHMENT_MAX_COUNT', DEFAULT_NATIVE_ATTACHMENT_MAX_COUNT),
    maxBytes: positiveIntegerEnv('OPENCODE_NATIVE_ATTACHMENT_MAX_BYTES', DEFAULT_NATIVE_ATTACHMENT_MAX_BYTES),
  };
}

function inspectNativeAttachment(filePath: string): NativeAttachmentFileInfo | null {
  try {
    const stat = lstatSync(filePath);
    if (!stat.isFile() || stat.isSymbolicLink()) return null;
    return { realPath: realpathSync(filePath), size: stat.size };
  } catch {
    return null;
  }
}

function isPathInside(parent: string, child: string): boolean {
  const relative = path.relative(parent, child);
  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
}

function isSafeComponent(value: string): boolean {
  return (
    value.length > 0 &&
    value !== '.' &&
    value !== '..' &&
    !value.includes('/') &&
    !value.includes('\\') &&
    !value.includes('\0')
  );
}

/**
 * Turn a turn's attachments into OpenCode file parts, so the model sees the
 * media itself rather than only the `[image: cat.png — saved to …]` line the
 * formatter already renders into the prompt text.
 *
 * The URL is a `file://` path, NOT a data: URI, deliberately: OpenCode resolves
 * a file: part server-side and converts supported local media for the model.
 * Base64-ing here would duplicate that work and inflate the request body. The
 * server shares this container's filesystem (spawnOpencodeServer), so the path
 * resolves.
 *
 * Only images and PDFs are forwarded; PDFs go through even though a given
 * backend may reject them, since the alternative is silently withholding a
 * document the user did send. Anything skipped is still described in the
 * prompt text, so it is never lost — just not handed over as media.
 *
 * `exists` is injectable so tests can drive resolvability without touching disk.
 */
export function buildAttachmentFileParts(
  attachments: OpenCodePromptAttachment[] | undefined,
  inspect: (path: string) => NativeAttachmentFileInfo | null = inspectNativeAttachment,
  limits: NativeAttachmentLimits = resolveNativeAttachmentLimits(),
): FilePartInput[] {
  const parts: FilePartInput[] = [];
  let totalBytes = 0;
  for (const att of attachments ?? []) {
    if (parts.length >= limits.maxCount) {
      log(`Native attachment count limit reached (${limits.maxCount}); remaining files stay prompt text only`);
      break;
    }
    if (!isSafeComponent(att.sourceMessageId) || !isSafeComponent(att.filename)) continue;
    const expectedRoot = `/workspace/inbox/${att.sourceMessageId}`;
    const expectedPath = `${expectedRoot}/${att.filename}`;
    if (path.resolve(att.path) !== expectedPath) {
      log(`Attachment path is not bound to its source message, not sent as media: ${att.filename}`);
      continue;
    }
    const mime = attachmentMime(att);
    if (!mime) continue;
    if (!mime.startsWith('image/') && mime !== 'application/pdf') continue;
    const info = inspect(att.path);
    if (!info || !isPathInside(expectedRoot, info.realPath) || path.basename(info.realPath) !== att.filename) {
      log(`Attachment has no safe regular file, not sent as media: ${att.filename}`);
      continue;
    }
    if (info.size < 0 || totalBytes + info.size > limits.maxBytes) {
      log(`Native attachment byte limit reached (${limits.maxBytes}); ${att.filename} stays prompt text only`);
      continue;
    }
    totalBytes += info.size;
    // OpenCode appends file parts after the combined batch text. Prefix the
    // display name with the source id so two messages carrying `image.png`
    // remain unambiguous to the model; the prompt text keeps the original name.
    parts.push({
      type: 'file',
      mime,
      filename: `${att.sourceMessageId}--${att.filename}`,
      url: pathToFileURL(info.realPath).href,
    });
  }
  return parts;
}

/**
 * The prompt body for one turn: the text the formatter produced, plus any
 * media that came with it. Both the opening prompt and every mid-turn push go
 * through here, so an attachment reaches the model the same way whichever path
 * carried it — OpenCode holds one query open per session, so in practice most
 * real messages arrive as pushes.
 */
export function buildPromptParts(
  text: string,
  attachments?: OpenCodePromptAttachment[],
  inspect: (path: string) => NativeAttachmentFileInfo | null = inspectNativeAttachment,
  limits: NativeAttachmentLimits = resolveNativeAttachmentLimits(),
): Array<{ type: 'text'; text: string } | FilePartInput> {
  return [{ type: 'text', text }, ...buildAttachmentFileParts(attachments, inspect, limits)];
}

type OpenCodeEvent = { type: string; properties: Record<string, unknown> };

/**
 * The client surface a shared runtime is built from: the per-turn session
 * calls `OpenCodeRuntimeHandle` already narrows, plus the event subscription
 * that only the shared (production) path opens. The real `OpencodeClient`
 * satisfies it structurally; tests hand in a fake.
 */
/**
 * The subset of the SDK's SSE options this module drives. `subscribe` spreads
 * them through `get.sse` → `beforeRequest` → `createSseClient` (verified in
 * @opencode-ai/sdk 1.18.25 dist/gen). Without a `signal`, that client swallows
 * a closed socket and reconnects forever with backoff, so a killed server
 * never ends the stream and an in-flight turn never learns it died.
 */
export interface SseSubscribeOptions {
  signal?: AbortSignal;
  sseSleepFn?: (ms: number) => Promise<void>;
  onSseError?: (error: unknown) => void;
}

type SharedRuntimeClient = OpenCodeRuntimeHandle['client'] & {
  event: { subscribe(options?: SseSubscribeOptions): Promise<{ stream: AsyncGenerator<OpenCodeEvent, void, void> }> };
};

/** The SDK's retry backoff, made to return the moment the runtime is released. */
function abortableSleep(signal: AbortSignal): (ms: number) => Promise<void> {
  return (ms) =>
    new Promise<void>((resolve) => {
      if (signal.aborted) return resolve();
      const timer = setTimeout(done, ms);
      function done(): void {
        clearTimeout(timer);
        signal.removeEventListener('abort', done);
        resolve();
      }
      signal.addEventListener('abort', done, { once: true });
    });
}

type SharedRuntime = {
  proc: ChildProcess;
  client: SharedRuntimeClient;
  questionClient: QuestionClient;
  stream: AsyncGenerator<OpenCodeEvent, void, void>;
  streamRelease: () => void;
};

/**
 * What `ensureSharedRuntime` needs from the outside world, injectable so the
 * shared-server lifecycle (spawn failure, init failure after spawn, server
 * death, stream death) can be driven in tests without an `opencode serve`
 * process. `OpenCodeRuntimeDeps` on the provider bypasses this whole path;
 * this seam exercises it.
 */
export interface OpenCodeSharedRuntimeDeps {
  spawnServer(config: Record<string, unknown>): Promise<{ url: string; proc: ChildProcess }>;
  createClient(url: string, cwd: string): SharedRuntimeClient;
  createQuestionClient(url: string): QuestionClient;
}

const defaultSharedRuntimeDeps: OpenCodeSharedRuntimeDeps = {
  spawnServer: (config) => spawnOpencodeServer(config),
  // OpenCode scopes sessions and tool execution by the directory carried by
  // the SDK client. The server process cwd is not sufficient: without this
  // option the SDK defaults requests to the server's launch directory.
  // The cast bridges one declared gap: the handle types `prompt` parts as
  // `unknown[]` so fakes stay light, while the SDK types them as its part
  // union. Every call site passes `buildPromptParts` output, which is the
  // SDK's own union, so the runtime shapes agree.
  createClient: (url, cwd) => createOpencodeClient({ baseUrl: url, directory: cwd }) as unknown as SharedRuntimeClient,
  createQuestionClient: (url) => createOpencodeQuestionClient({ baseUrl: url }),
};

let sharedRuntimeDeps: OpenCodeSharedRuntimeDeps = defaultSharedRuntimeDeps;

export function setSharedRuntimeDepsForTesting(deps?: OpenCodeSharedRuntimeDeps): void {
  sharedRuntimeDeps = deps ?? defaultSharedRuntimeDeps;
}

let sharedRuntime: SharedRuntime | null = null;
let sharedConfigKey: string | null = null;
let sharedInit: Promise<SharedRuntime> | null = null;

/**
 * One `opencode serve` per container, reused across queries. Every failure
 * mode leaves the module in a state the NEXT call can recover from: a failed
 * init is never cached (so a slow listen line or a stolen port costs one turn,
 * not the container's lifetime), a spawned server whose client setup fails is
 * reaped rather than orphaned on its port, and a server that exits out from
 * under us drops itself from the cache so the next turn respawns instead of
 * failing instantly forever.
 */
async function ensureSharedRuntime(
  options: ProviderOptions,
  cwd: string,
  configuration?: ResolvedRuntimeConfiguration,
): Promise<SharedRuntime> {
  const config = buildOpenCodeConfig(options, configuration);
  const key = JSON.stringify({ config, cwd });
  if (sharedRuntime && sharedConfigKey === key) return sharedRuntime;

  if (sharedInit) return sharedInit;

  const deps = sharedRuntimeDeps;
  const init = (async (): Promise<SharedRuntime> => {
    if (sharedRuntime) {
      destroySharedRuntime();
    }
    const { url, proc } = await deps.spawnServer(config);

    let runtime: SharedRuntime;
    // Owns the SSE subscription and its retry loop. Teardown closes the
    // server socket and prevents reconnection, waking a parked next() so an
    // active turn can report stream termination.
    const streamAbort = new AbortController();
    // SDK 1.18.25's abort handler does not handle reader.cancel() rejection.
    // Cancel the fetch only after its reader listener is gone. A separate
    // signal wakes retry backoff immediately when teardown was requested.
    const releaseAbort = new AbortController();
    const sleep = abortableSleep(releaseAbort.signal);
    try {
      const client = deps.createClient(url, cwd);
      const questionClient = deps.createQuestionClient(url);
      // Deliberately no `sseMaxRetryAttempts`: the SDK counts attempts
      // cumulatively per subscription and never resets after a successful
      // reconnect, so a cap would end a long-lived container's stream for
      // good on the Nth transient /event hiccup. The abort signal (server
      // exit, teardown) and the stream-silence watchdog are the stops.
      const sub = await client.event.subscribe({
        signal: streamAbort.signal,
        onSseError: () => {
          // The generated SDK calls this after removing its reader listener.
          if (releaseAbort.signal.aborted) streamAbort.abort();
        },
        sseSleepFn: async (ms) => {
          await sleep(ms);
          if (releaseAbort.signal.aborted) streamAbort.abort();
        },
      });
      const stream = sub.stream;
      // Belt-and-suspenders drain before this runtime serves any turn — see
      // drainPendingQuestions doc comment.
      await drainPendingQuestions(questionClient);
      runtime = {
        proc,
        client,
        questionClient,
        stream,
        streamRelease: () => {
          releaseAbort.abort();
          // return() closes an idle reader. If next() is parked, killing the
          // owned server closes its socket and onSseError ends the retry loop.
          // Both paths remove the broken listener before aborting the fetch.
          void stream.return(undefined).then(
            () => streamAbort.abort(),
            () => streamAbort.abort(),
          );
        },
      };
    } catch (err) {
      // The server came up and is holding its port; nothing downstream will
      // ever hold a handle to it, so this is the only place it can be reaped.
      streamAbort.abort();
      killProcessTree(proc);
      throw err;
    }

    const onExit = (code: number | null, signal: NodeJS.Signals | null): void => {
      if (sharedRuntime?.proc !== proc) return;
      log(`OpenCode server exited (code=${String(code)}, signal=${String(signal)}); next turn will respawn it`);
      try {
        runtime.streamRelease();
      } catch {
        /* ignore */
      }
      sharedRuntime = null;
      sharedConfigKey = null;
    };
    proc.once('exit', onExit);
    if (proc.exitCode !== null || proc.signalCode !== null) {
      // Died between the listen line and the listener — the event is gone.
      try {
        runtime.streamRelease();
      } catch {
        /* ignore */
      }
      throw new Error(`OpenCode server exited during startup (code=${String(proc.exitCode)})`);
    }

    sharedRuntime = runtime;
    sharedConfigKey = key;
    return runtime;
  })();

  sharedInit = init;
  const release = (): void => {
    if (sharedInit === init) sharedInit = null;
  };
  init.then(release, release);
  return init;
}

export function destroySharedRuntime(): void {
  if (sharedRuntime) {
    try {
      sharedRuntime.streamRelease();
    } catch {
      /* ignore */
    }
    killProcessTree(sharedRuntime.proc);
    sharedRuntime = null;
    sharedConfigKey = null;
  }
  sharedInit = null;
}

/**
 * The shared runtime's event stream died under a turn (SSE ended or threw).
 * Only the shared runtime is dropped, and only if `rt` is still it — a
 * test-injected handle or a runtime that was already replaced is untouched.
 */
function discardDeadSharedRuntime(rt: unknown): void {
  if (sharedRuntime && rt === sharedRuntime) {
    log('OpenCode event stream died; dropping shared runtime so the next turn respawns it');
    destroySharedRuntime();
  }
}

// Steers the model rather than just silently declining: nothing in this
// container can answer an interactive question, so tell it to decide on its
// own or fall back to nanoclaw's own blocking MCP tool (mcp-tools/interactive.ts,
// registered as `ask_user_question`), which actually reaches the human through
// the chat channel instead of OpenCode's headless-dead-end question tool.
export const QUESTION_STEERING_TEXT =
  'Interactive questions are not available in this environment. Decide autonomously based on your best judgment, or use the ask_user_question MCP tool to ask the human through the chat channel.';

/**
 * Minimal shape of the `/v2` SDK surface this module needs for question
 * handling — narrowed so tests can pass a fake without pulling in the real
 * `@opencode-ai/sdk/v2` client.
 */
export interface QuestionClient {
  question: {
    reply(params: { requestID: string; answers: string[][] }): Promise<{ data?: unknown; error?: unknown }>;
    list(): Promise<{ data?: Array<{ id: string; sessionID?: string; questions?: unknown[] }>; error?: unknown }>;
  };
}

/**
 * Narrow runtime surface so tests can drive `query()` without spawning
 * `opencode serve`. Production uses `ensureSharedRuntime`.
 */
export interface OpenCodeRuntimeHandle {
  client: {
    session: OpenCodeSessionClient;
    postSessionIdPermissionsPermissionId?(params: {
      path: { id: string; permissionID: string };
      body: { response: string };
    }): Promise<unknown>;
  };
  stream: AsyncGenerator<{ type: string; properties: Record<string, unknown> }, void, void>;
  questionClient: QuestionClient;
  /** Ends the event stream, waking any parked `stream.next()`. */
  streamRelease?(): void;
}

export interface OpenCodeRuntimeDeps {
  getRuntime(options: ProviderOptions, cwd: string): Promise<OpenCodeRuntimeHandle>;
}

/**
 * Answer a single pending question request with the steering text, one
 * custom answer per sub-question (OpenCode's `question` tool defaults
 * `custom: true`, i.e. an answer string that isn't one of the offered
 * option labels is accepted as free text). Never throws — a failed
 * auto-answer should not take down the session any more than the question
 * already threatened to.
 */
export async function autoAnswerQuestion(
  questionClient: QuestionClient,
  req: { id?: string; questions?: unknown[] },
): Promise<void> {
  if (!req.id) return;
  const count = Array.isArray(req.questions) && req.questions.length > 0 ? req.questions.length : 1;
  try {
    const res = await questionClient.question.reply({
      requestID: req.id,
      answers: Array.from({ length: count }, () => [QUESTION_STEERING_TEXT]),
    });
    if (res.error) {
      log(`Failed to auto-answer question ${req.id}: ${JSON.stringify(res.error)}`);
    }
  } catch (err) {
    log(`Failed to auto-answer question ${req.id}: ${err instanceof Error ? err.message : String(err)}`);
  }
}

/**
 * Matches the startup-blocking budget `spawnOpencodeServer` already uses for
 * its own default `timeoutMs`. This is a startup-path call like that one, so
 * it gets the same allowance. Shared with `handleQuestionAsked` below — the
 * same fail-open budget applies whether a hung reply is discovered at
 * runtime startup or mid-turn.
 */
const DRAIN_PENDING_QUESTIONS_TIMEOUT_MS = 10_000;

async function waitForQuestionResponse(operation: Promise<void>, timeoutMs: number, context: string): Promise<void> {
  let timer: ReturnType<typeof setTimeout> | undefined;
  const timedOut = new Promise<true>((resolve) => {
    timer = setTimeout(() => resolve(true), timeoutMs);
  });

  try {
    if (await Promise.race([operation.then(() => false as const), timedOut])) {
      log(`Timed out after ${timeoutMs}ms ${context}`);
    }
  } finally {
    clearTimeout(timer);
  }
}

/**
 * Handle a `question.asked` SSE event: always answer it, regardless of which
 * session raised it. The `question: 'deny'` config above should stop this
 * tool from ever firing, but this is the real fix for the wedge: the
 * OpenCode server is shared across every session on this runtime, and a
 * pending question wedges the whole server, not just the session that asked
 * — so a config regression or an OpenCode-side path that raises the event
 * before consulting permission must never be able to leave a question
 * unanswered, no matter whose sessionID it carries. Same rule as
 * `drainPendingQuestions`, so behavior does not depend on which path sees a
 * question first.
 *
 * The event pump starts this handler without awaiting it, so a hung reply
 * cannot block event consumption. A bounded wait still reports a stalled
 * question and releases this handler. On timeout it logs and returns,
 * fail-open, like the startup drain. Tests can inject a shorter budget.
 */
export async function handleQuestionAsked(
  questionClient: QuestionClient,
  req: { id?: string; sessionID?: string; questions?: unknown[] },
  timeoutMs = DRAIN_PENDING_QUESTIONS_TIMEOUT_MS,
): Promise<void> {
  log(`Auto-answering question ${req.id ?? '(no id)'} (sessionID=${req.sessionID ?? 'unknown'})`);

  await waitForQuestionResponse(
    autoAnswerQuestion(questionClient, req),
    timeoutMs,
    `auto-answering question ${req.id ?? '(no id)'}; continuing`,
  );
}

/**
 * Defensive belt: drain any question requests already pending when a shared
 * runtime comes up (e.g. one that raced the event subscription, or survived
 * from a prior server instance) so none of them can sit there wedging future
 * turns before the event-driven handler ever sees them.
 *
 * Bounded the same way `spawnOpencodeServer` bounds its own await: a plain
 * `Promise.race` against a timer, since (unlike that function's child-process
 * spawn) there is no cancellable handle on the in-flight SDK calls to abort.
 * A hung list()/reply() round-trip must not block runtime startup forever —
 * on timeout this logs one line and returns, fail-open, because the
 * event-driven `question.asked` handler still answers the question later if
 * the round-trip eventually completes.
 */
export async function drainPendingQuestions(
  questionClient: QuestionClient,
  timeoutMs = DRAIN_PENDING_QUESTIONS_TIMEOUT_MS,
): Promise<void> {
  const drain = (async () => {
    try {
      const res = await questionClient.question.list();
      if (res.error) {
        log(`Failed to list pending questions: ${JSON.stringify(res.error)}`);
        return;
      }
      for (const req of res.data ?? []) {
        await autoAnswerQuestion(questionClient, req);
      }
    } catch (err) {
      log(`Failed to list pending questions: ${err instanceof Error ? err.message : String(err)}`);
    }
  })();

  await waitForQuestionResponse(drain, timeoutMs, 'draining pending questions; continuing startup');
}

const runtimePumps = new WeakMap<OpenCodeRuntimeHandle, OpenCodeEventPump>();

function eventPump(runtime: OpenCodeRuntimeHandle): OpenCodeEventPump {
  let pump = runtimePumps.get(runtime);
  if (!pump) {
    pump = new OpenCodeEventPump(runtime.stream, (event) => {
      if (event.type === 'question.asked') {
        void handleQuestionAsked(runtime.questionClient, event.properties);
      }
      if (event.type === 'permission.updated') {
        const permission = event.properties as { id?: string; sessionID?: string };
        if (permission.id && permission.sessionID) {
          void boundedOpenCodeCall(
            () =>
              runtime.client.postSessionIdPermissionsPermissionId?.({
                path: { id: permission.sessionID!, permissionID: permission.id! },
                body: { response: 'always' },
              }) ?? Promise.resolve(),
          ).catch(() => log('Failed to auto-reply OpenCode permission'));
        }
      }
    });
    runtimePumps.set(runtime, pump);
  }
  return pump;
}

export class OpenCodeProvider implements AgentProvider {
  readonly supportsNativeSlashCommands = false;
  private memorySessionHook?: OpenCodeMemorySessionHook;

  constructor(
    private readonly options: ProviderOptions = {},
    private readonly runtime?: OpenCodeRuntimeDeps,
    private readonly configuration?: ResolvedRuntimeConfiguration,
  ) {}

  registerMemorySessionHook(hook: OpenCodeMemorySessionHook, configuration?: unknown): void {
    this.memorySessionHook = (configuration ?? hook) as OpenCodeMemorySessionHook;
  }

  isSessionInvalid(error: unknown): boolean {
    return STALE_SESSION_RE.test(error instanceof Error ? error.message : String(error));
  }

  query(input: QueryInput): AgentQuery {
    if (!this.memorySessionHook) throw new Error('OpenCode memory session hook was not registered');
    const pending: Array<{ text: string; attachments?: OpenCodePromptAttachment[] }> = [
      {
        text: input.prompt,
        attachments: (input as QueryInput & { attachments?: OpenCodePromptAttachment[] }).attachments,
      },
    ];
    let waiting: (() => void) | undefined;
    let ended = false;
    const abort = new AbortController();
    const self = this;

    async function* gen(): AsyncGenerator<ProviderEvent> {
      let sessionId = input.continuation;
      let initialized = false;
      try {
        const runtime = self.runtime
          ? await self.runtime.getRuntime(self.options, input.cwd)
          : await ensureSharedRuntime(self.options, input.cwd, self.configuration);
        const pump = eventPump(runtime);
        const promptModel = resolveOpenCodePromptModel(
          (self.configuration?.inference ?? resolveOpenCodeInference(self.options, process.env)) as Record<
            string,
            unknown
          >,
        );
        while (!abort.signal.aborted) {
          while (!pending.length && !ended && !abort.signal.aborted) {
            await new Promise<void>((resolve) => {
              waiting = resolve;
            });
            waiting = undefined;
          }
          if (abort.signal.aborted || (!pending.length && ended)) return;
          const turn = pending.shift()!;
          if (!sessionId) {
            const created = await boundedOpenCodeCall(
              (signal) => runtime.client.session.create({ signal }),
              abort.signal,
            );
            if (created.error) throw new Error(`OpenCode failed to create session: ${JSON.stringify(created.error)}`);
            sessionId = created.data?.id;
            if (!sessionId) throw new Error('OpenCode failed to create session (no id)');
          }
          if (!initialized) {
            initialized = true;
            yield { type: 'init', continuation: sessionId };
          }
          const result = yield* executeOpenCodeTurn({
            runtime,
            client: runtime.client.session,
            pump,
            sessionId,
            parts: buildPromptParts(turn.text, turn.attachments),
            model: promptModel,
            prepare: () => {
              prepareOpenCodeMemory(
                self.memorySessionHook!,
                input.systemContext?.instructions,
                buildDeliverySentences(
                  getAllDestinations().map((destination) => destination.name),
                  getTaskSeriesId(),
                ).join(' '),
              );
            },
            signal: abort.signal,
            silenceMs: positiveIntegerEnv('OPENCODE_STREAM_SILENCE_MS', DEFAULT_STREAM_SILENCE_MS),
            idleMs: positiveIntegerEnv('OPENCODE_IDLE_TIMEOUT_MS', DEFAULT_IDLE_TIMEOUT_MS),
            discard: () => {
              discardDeadSharedRuntime(runtime);
              runtime.streamRelease?.();
            },
          });
          if (!abort.signal.aborted) yield { type: 'result', ...result };
        }
      } catch (error) {
        if (!abort.signal.aborted) throw error;
      } finally {
        abort.abort();
      }
    }

    return {
      push: (text: string, attachments?: OpenCodePromptAttachment[]) => {
        if (ended || abort.signal.aborted) return;
        pending.push({ text, attachments });
        waiting?.();
      },
      end: () => {
        ended = true;
        waiting?.();
      },
      events: gen(),
      abort: () => {
        abort.abort();
        waiting?.();
      },
    };
  }
}

registerProvider('opencode', (opts, configuration) => new OpenCodeProvider(opts, undefined, configuration));