@ai-sdk/harness-opencode 0.0.0-07500555-20260730161446

package/src/bridge/opencode-events.ts

@@ -0,0 +1,270 @@
+export type OpenCodeEvent = {
+  id?: string;
+  type?: string;
+  properties?: Record<string, any>;
+};
+
+type Emit = (msg: Record<string, unknown>) => void;
+
+export type TranslationState = {
+  textDeltas: Map<string, string>;
+  reasoningDeltas: Map<string, string>;
+  toolInputs: Map<string, string>;
+  toolNames: Map<string, { rawToolName: string; toolName: string }>;
+  toolCallsEmitted: Set<string>;
+  toolResultsEmitted: Set<string>;
+  hostToolCallsAuthorized: Set<string>;
+  shellCommands: Map<string, string>;
+  messageRoles: Map<string, string>;
+  turnUsage: Record<string, unknown> | undefined;
+  legacyTextPartIds: Set<string>;
+  legacyReasoningPartIds: Set<string>;
+  legacyStepFinishPartIds: Set<string>;
+};
+
+export function createTranslationState(): TranslationState {
+  return {
+    textDeltas: new Map(),
+    reasoningDeltas: new Map(),
+    toolInputs: new Map(),
+    toolNames: new Map(),
+    toolCallsEmitted: new Set(),
+    toolResultsEmitted: new Set(),
+    hostToolCallsAuthorized: new Set(),
+    shellCommands: new Map(),
+    messageRoles: new Map(),
+    turnUsage: undefined,
+    legacyTextPartIds: new Set(),
+    legacyReasoningPartIds: new Set(),
+    legacyStepFinishPartIds: new Set(),
+  };
+}
+
+export function unwrapOpenCodeEvent(
+  rawEvent: unknown,
+): OpenCodeEvent | undefined {
+  if (!rawEvent || typeof rawEvent !== 'object') return undefined;
+  const raw = rawEvent as Record<string, any>;
+  if (raw.type === 'sync' && raw.syncEvent) {
+    const sync = raw.syncEvent as Record<string, any>;
+    return {
+      id: String(sync.id ?? raw.id ?? ''),
+      type: stripSyncVersion(String(sync.type ?? '')),
+      properties: asRecord(sync.data) ?? {},
+    };
+  }
+  return {
+    id: typeof raw.id === 'string' ? raw.id : undefined,
+    type: typeof raw.type === 'string' ? stripSyncVersion(raw.type) : undefined,
+    properties: asRecord(raw.properties) ?? asRecord(raw.data) ?? {},
+  };
+}
+
+export function getOpenCodeEventSessionId(
+  event: OpenCodeEvent,
+): string | undefined {
+  const props = event.properties;
+  if (!props) return undefined;
+  if (typeof props.sessionID === 'string') return props.sessionID;
+  if (typeof props.sessionId === 'string') return props.sessionId;
+  if (event.type?.startsWith('session.') && typeof props.id === 'string') {
+    return props.id;
+  }
+  const part = props.part;
+  if (
+    part &&
+    typeof part === 'object' &&
+    !Array.isArray(part) &&
+    typeof (part as { sessionID?: unknown }).sessionID === 'string'
+  ) {
+    return (part as { sessionID: string }).sessionID;
+  }
+  return undefined;
+}
+
+export function isStepSettlementEvent(event: OpenCodeEvent): boolean {
+  return (
+    event.type === 'session.next.step.ended' ||
+    event.type === 'session.next.step.failed' ||
+    event.type === 'session.error'
+  );
+}
+
+export function emitMissingFinalDelta({
+  id,
+  fullText,
+  emittedText,
+  emit,
+  type,
+}: {
+  id: string;
+  fullText: string | undefined;
+  emittedText: string;
+  emit: (msg: Record<string, unknown>) => void;
+  type: 'text-delta' | 'reasoning-delta';
+}): void {
+  if (
+    !fullText ||
+    fullText === emittedText ||
+    !fullText.startsWith(emittedText)
+  ) {
+    return;
+  }
+  emit({ type, id, delta: fullText.slice(emittedText.length) });
+}
+
+/**
+ * Translates an OpenCode `message.part.delta` event (a streaming text or
+ * reasoning delta) into legacy stream parts.
+ */
+export function emitLegacyPartDelta({
+  props,
+  state,
+  emit,
+}: {
+  props: Record<string, unknown>;
+  state: TranslationState;
+  emit: Emit;
+}): void {
+  const field = String(props.field ?? '');
+  const delta = String(props.delta ?? '');
+  if (!delta) return;
+  const messageID = stringValue(props.messageID);
+  if (messageID && state.messageRoles.get(messageID) === 'user') return;
+  if (field === 'text') {
+    const id = legacyPartId({ value: props, fallback: 'legacy-text' });
+    // OpenCode publishes reasoning deltas with field:"text". If this id was
+    // already announced as a reasoning part, route it to reasoning so it is not
+    // duplicated as a text part.
+    if (state.legacyReasoningPartIds.has(id)) {
+      state.reasoningDeltas.set(
+        id,
+        `${state.reasoningDeltas.get(id) ?? ''}${delta}`,
+      );
+      emit({ type: 'reasoning-delta', id, delta });
+      return;
+    }
+    startLegacyPart({ ids: state.legacyTextPartIds, id, emit, type: 'text' });
+    state.textDeltas.set(id, `${state.textDeltas.get(id) ?? ''}${delta}`);
+    emit({ type: 'text-delta', id, delta });
+    return;
+  }
+  if (field === 'reasoning') {
+    const id = legacyPartId({ value: props, fallback: 'legacy-reasoning' });
+    startLegacyPart({
+      ids: state.legacyReasoningPartIds,
+      id,
+      emit,
+      type: 'reasoning',
+    });
+    state.reasoningDeltas.set(
+      id,
+      `${state.reasoningDeltas.get(id) ?? ''}${delta}`,
+    );
+    emit({ type: 'reasoning-delta', id, delta });
+  }
+}
+
+/**
+ * Translates an OpenCode `message.part.updated` event for a text or reasoning
+ * part. Returns `true` when it handled the part.
+ */
+export function emitLegacyTextPartUpdate({
+  part,
+  state,
+  emit,
+}: {
+  part: unknown;
+  state: TranslationState;
+  emit: Emit;
+}): boolean {
+  if (!isRecord(part)) return false;
+  if (part.type !== 'text' && part.type !== 'reasoning') return false;
+  const id = stringValue(part.id);
+  if (!id) return true;
+
+  const messageID = stringValue(part.messageID);
+  if (messageID && state.messageRoles.get(messageID) === 'user') return true;
+
+  const isReasoning = part.type === 'reasoning';
+  const ids = isReasoning
+    ? state.legacyReasoningPartIds
+    : state.legacyTextPartIds;
+  const deltaMap = isReasoning ? state.reasoningDeltas : state.textDeltas;
+  const deltaType = isReasoning ? 'reasoning-delta' : 'text-delta';
+  const text = typeof part.text === 'string' ? part.text : undefined;
+
+  startLegacyPart({
+    ids,
+    id,
+    emit,
+    type: isReasoning ? 'reasoning' : 'text',
+  });
+
+  if (text !== undefined) {
+    emitMissingFinalDelta({
+      id,
+      fullText: text,
+      emittedText: deltaMap.get(id) ?? '',
+      emit,
+      type: deltaType,
+    });
+    deltaMap.set(id, text);
+  }
+
+  if (legacyPartEnded(part)) {
+    ids.delete(id);
+    deltaMap.delete(id);
+    emit({ type: isReasoning ? 'reasoning-end' : 'text-end', id });
+  }
+
+  return true;
+}
+
+function stripSyncVersion(type: string): string {
+  return type.replace(/\.\d+$/, '');
+}
+
+function asRecord(value: unknown): Record<string, any> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    return undefined;
+  return value as Record<string, any>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+
+function legacyPartId({
+  value,
+  fallback,
+}: {
+  value: Record<string, unknown>;
+  fallback: string;
+}): string {
+  return stringValue(value.partID) ?? stringValue(value.id) ?? fallback;
+}
+
+function startLegacyPart({
+  ids,
+  id,
+  emit,
+  type,
+}: {
+  ids: Set<string>;
+  id: string;
+  emit: Emit;
+  type: 'text' | 'reasoning';
+}): void {
+  if (ids.has(id)) return;
+  ids.add(id);
+  emit({ type: `${type}-start`, id });
+}
+
+function legacyPartEnded(part: Record<string, unknown>): boolean {
+  return isRecord(part.time) && part.time.end != null;
+}

package/src/bridge/opencode-finish-step.ts

@@ -0,0 +1,39 @@
+import type { HarnessV1StreamPart } from '@ai-sdk/harness';
+import { mapUsage } from './opencode-usage';
+
+type FinishStepEvent = Extract<HarnessV1StreamPart, { type: 'finish-step' }>;
+
+export function mapOpenCodeFinishReason(
+  reason: string,
+): 'stop' | 'length' | 'content-filter' | 'tool-calls' | 'error' | 'other' {
+  const normalized = reason.toLowerCase();
+  if (normalized.includes('length')) return 'length';
+  if (normalized.includes('filter')) return 'content-filter';
+  if (normalized.includes('tool')) return 'tool-calls';
+  if (normalized.includes('error') || normalized.includes('fail'))
+    return 'error';
+  if (normalized === 'stop' || normalized === 'end') return 'stop';
+  return 'other';
+}
+
+export function legacyStepFinishPartToFinishStep(
+  part: unknown,
+): FinishStepEvent | undefined {
+  if (!isRecord(part) || part.type !== 'step-finish') return undefined;
+  const rawFinish = typeof part.reason === 'string' ? part.reason : 'stop';
+  return {
+    type: 'finish-step',
+    finishReason: {
+      unified: mapOpenCodeFinishReason(rawFinish),
+      raw: rawFinish,
+    },
+    usage: mapUsage(part.tokens),
+    ...(typeof part.cost === 'number'
+      ? { harnessMetadata: { opencode: { cost: part.cost } } }
+      : {}),
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/src/bridge/opencode-path.ts

@@ -0,0 +1,17 @@
+import path from 'node:path';
+
+const fallbackPath =
+  '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin';
+
+export function prependOpenCodeBinToPath({
+  bootstrapDir,
+  env,
+}: {
+  bootstrapDir: string;
+  env: NodeJS.ProcessEnv;
+}): void {
+  env.PATH = [
+    path.join(bootstrapDir, 'node_modules', '.bin'),
+    env.PATH || fallbackPath,
+  ].join(path.delimiter);
+}

package/src/bridge/opencode-usage.ts

@@ -0,0 +1,160 @@
+import type { HarnessV1StreamPart } from '@ai-sdk/harness';
+
+type FinishStepEvent = Extract<HarnessV1StreamPart, { type: 'finish-step' }>;
+
+export type OpenCodeTokenUsage = {
+  readonly input: number;
+  readonly output: number;
+  readonly reasoning: number;
+  readonly cache: {
+    readonly read: number;
+    readonly write: number;
+  };
+};
+
+export type HarnessUsage = FinishStepEvent['usage'];
+
+export function mapUsage(tokens: unknown): HarnessUsage {
+  const value = extractOpenCodeTokens(tokens) ?? zeroOpenCodeTokens();
+  const cacheRead = value.cache.read;
+  return {
+    inputTokens: {
+      total: value.input,
+      noCache: Math.max(0, value.input - cacheRead),
+      cacheRead,
+      cacheWrite: value.cache.write,
+    },
+    outputTokens: {
+      total: value.output + value.reasoning,
+      text: value.output,
+      reasoning: value.reasoning,
+    },
+  };
+}
+
+export function defaultUsage(): HarnessUsage {
+  return mapUsage(zeroOpenCodeTokens());
+}
+
+export function extractSessionTokens(
+  value: unknown,
+): OpenCodeTokenUsage | undefined {
+  const record = asRecord(value);
+  if (!record) return undefined;
+  const tokens =
+    extractOpenCodeTokens(record.tokens) ??
+    extractOpenCodeTokens(asRecord(record.info)?.tokens) ??
+    extractOpenCodeTokens(asRecord(record.data)?.tokens) ??
+    extractOpenCodeTokens(asRecord(asRecord(record.data)?.data)?.tokens);
+  return tokens;
+}
+
+export function subtractSessionTokens({
+  before,
+  after,
+}: {
+  before: OpenCodeTokenUsage;
+  after: OpenCodeTokenUsage;
+}): OpenCodeTokenUsage {
+  return {
+    input: diff({ before: before.input, after: after.input }),
+    output: diff({ before: before.output, after: after.output }),
+    reasoning: diff({ before: before.reasoning, after: after.reasoning }),
+    cache: {
+      read: diff({ before: before.cache.read, after: after.cache.read }),
+      write: diff({ before: before.cache.write, after: after.cache.write }),
+    },
+  };
+}
+
+export function addUsage({
+  left,
+  right,
+}: {
+  left: HarnessUsage | undefined;
+  right: HarnessUsage;
+}): HarnessUsage {
+  if (left == null) return right;
+  const leftInput = asTokenGroup(left.inputTokens);
+  const rightInput = asTokenGroup(right.inputTokens);
+  const leftOutput = asTokenGroup(left.outputTokens);
+  const rightOutput = asTokenGroup(right.outputTokens);
+  return {
+    inputTokens: {
+      total: add({ left: leftInput.total, right: rightInput.total }),
+      noCache: add({ left: leftInput.noCache, right: rightInput.noCache }),
+      cacheRead: add({
+        left: leftInput.cacheRead,
+        right: rightInput.cacheRead,
+      }),
+      cacheWrite: add({
+        left: leftInput.cacheWrite,
+        right: rightInput.cacheWrite,
+      }),
+    },
+    outputTokens: {
+      total: add({ left: leftOutput.total, right: rightOutput.total }),
+      text: add({ left: leftOutput.text, right: rightOutput.text }),
+      reasoning: add({
+        left: leftOutput.reasoning,
+        right: rightOutput.reasoning,
+      }),
+    },
+  };
+}
+
+function extractOpenCodeTokens(value: unknown): OpenCodeTokenUsage | undefined {
+  const record = asRecord(value);
+  const cache = asRecord(record?.cache);
+  if (!record || !cache) return undefined;
+  return {
+    input: numberValue(record.input),
+    output: numberValue(record.output),
+    reasoning: numberValue(record.reasoning),
+    cache: {
+      read: numberValue(cache.read),
+      write: numberValue(cache.write),
+    },
+  };
+}
+
+function zeroOpenCodeTokens(): OpenCodeTokenUsage {
+  return {
+    input: 0,
+    output: 0,
+    reasoning: 0,
+    cache: { read: 0, write: 0 },
+  };
+}
+
+function asTokenGroup(value: unknown): Record<string, number | undefined> {
+  return asRecord(value) ?? {};
+}
+
+function asRecord(value: unknown): Record<string, any> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    return undefined;
+  return value as Record<string, any>;
+}
+
+function numberValue(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+function diff({ before, after }: { before: number; after: number }): number {
+  return Math.max(0, after - before);
+}
+
+function add({
+  left,
+  right,
+}: {
+  left: unknown;
+  right: unknown;
+}): number | undefined {
+  const leftNumber = typeof left === 'number' ? left : undefined;
+  const rightNumber = typeof right === 'number' ? right : undefined;
+  return leftNumber == null && rightNumber == null
+    ? undefined
+    : (leftNumber ?? 0) + (rightNumber ?? 0);
+}

package/src/bridge/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "harness-opencode-bridge",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "@opencode-ai/sdk": "1.18.3",
+    "opencode-ai": "1.18.3",
+    "ws": "8.21.0",
+    "zod": "3.25.76"
+  }
+}