@ai-sdk/harness-opencode 0.0.0-cca10482-20260708215408

package/src/bridge/opencode-events.ts

@@ -0,0 +1,88 @@
+export type OpenCodeEvent = {
+  id?: string;
+  type?: string;
+  properties?: Record<string, any>;
+};
+
+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) });
+}
+
+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>;
+}

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,156 @@
+export type OpenCodeTokenUsage = {
+  readonly input: number;
+  readonly output: number;
+  readonly reasoning: number;
+  readonly cache: {
+    readonly read: number;
+    readonly write: number;
+  };
+};
+
+export type HarnessUsage = Record<string, unknown>;
+
+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.17.6",
+    "opencode-ai": "1.17.6",
+    "ws": "8.21.0",
+    "zod": "3.25.76"
+  }
+}