@agentex/agent 0.0.27 → 0.0.28

package/src/providers/opencode/execute.ts

@@ -3,7 +3,6 @@ import type { ExecutionContext, ExecutionResult } from "../../types.js";
 import { findBinary } from "../../utils/binary.js";
 import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
 import { runChildProcess, deriveErrorCode } from "../../utils/process.js";
-import { injectHomeSkills } from "../../utils/skills.js";
 import { resolveInstructions } from "../../utils/instructions.js";
 import { prepareWorkspace } from "../../utils/workspace.js";
 import type { PreparedWorkspace } from "../../utils/workspace.js";
@@ -14,6 +13,7 @@ import {
   isOpenCodeUnknownSessionError,
   isOpenCodeAuthRequired,
 } from "./parse.js";
+import { prepareOpenCodeSkillConfig } from "./skill-config.js";
 
 export async function executeOpenCodeProvider(ctx: ExecutionContext): Promise<ExecutionResult> {
   const runId = ctx.runId ?? uuidv7();
@@ -29,6 +29,31 @@ export async function executeOpenCodeProvider(ctx: ExecutionContext): Promise<Ex
     resolvedBinary = await findBinary("opencode", config.command);
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : "Binary not found";
+    const completedAt = new Date().toISOString();
+    if (ctx.onEvent) {
+      try {
+        await ctx.onEvent({
+          type: "result",
+          text: errorMessage,
+          costUsd: null,
+          isError: true,
+          stopReason: null,
+          terminalReason: "failed",
+          numTurns: null,
+          durationMs: new Date(completedAt).getTime() - new Date(startedAt).getTime(),
+          timestamp: completedAt,
+          providerType: "opencode",
+          sessionId: null,
+          messageId: null,
+          eventId: null,
+          turnId: null,
+          parentToolCallId: null,
+          raw: {},
+        });
+      } catch {
+        // A host event handler cannot fail the execution.
+      }
+    }
     ctx.onLifecycle?.({ phase: "error", message: errorMessage });
     return {
       runId,
@@ -36,7 +61,7 @@ export async function executeOpenCodeProvider(ctx: ExecutionContext): Promise<Ex
       signal: null,
       status: "failed" as const,
       startedAt,
-      completedAt: new Date().toISOString(),
+      completedAt,
       durationMs: Date.now() - new Date(startedAt).getTime(),
       errorMessage,
       errorCode: "binary_not_found",
@@ -59,24 +84,20 @@ export async function executeOpenCodeProvider(ctx: ExecutionContext): Promise<Ex
   }
 
   // 3. Build env
-  const env = buildEnv(ctx.env);
-  ensurePathInEnv(env);
+  const baseEnv = buildEnv(ctx.env);
+  ensurePathInEnv(baseEnv);
 
   // 3. Resolve instructions
   ctx.onLifecycle?.({ phase: "preparing", step: "instructions" });
   const instructions = await resolveInstructions(config.instructionsFile);
   const fullPrompt = instructions ? `${instructions}\n\n${ctx.prompt}` : ctx.prompt;
 
-  // 4. Inject skills into ~/.claude/skills/ (OpenCode shares Claude's skills dir)
+  // 4. Inject skills through an isolated OpenCode config directory.
   ctx.onLifecycle?.({ phase: "preparing", step: "skills" });
-  if (config.skillDirs && config.skillDirs.length > 0) {
-    try {
-      await injectHomeSkills(config.skillDirs, "opencode");
-    } catch {
-      // Non-fatal
-    }
-  }
+  const skillConfig = await prepareOpenCodeSkillConfig(baseEnv, config.skillDirs);
+  const env = skillConfig.env;
 
+  try {
   // 4. Determine session resume
   const sessionParams = ctx.sessionParams ?? null;
   const sessionId = (() => {
@@ -96,6 +117,9 @@ export async function executeOpenCodeProvider(ctx: ExecutionContext): Promise<Ex
     const args = [...resolvedBinary.prefixArgs, "run", "--format", "json"];
     if (resumeSessionId) args.push("--session", resumeSessionId);
     if (model) args.push("--model", model);
+    if (config.modelVariant) args.push("--variant", config.modelVariant);
+    const agent = config.planMode ? "plan" : (config.modeId ?? config.mode);
+    if (agent) args.push("--agent", agent);
     if (config.extraArgs) args.push(...config.extraArgs);
     return args;
   };
@@ -217,6 +241,31 @@ export async function executeOpenCodeProvider(ctx: ExecutionContext): Promise<Ex
     : (errorCode || errorMessage) ? "failed" as const
     : "completed" as const;
 
+  if (ctx.onEvent) {
+    try {
+      await ctx.onEvent({
+        type: "result",
+        text: parsed.summary ?? errorMessage ?? "",
+        costUsd: parsed.costUsd,
+        isError: status !== "completed",
+        stopReason: null,
+        terminalReason: status,
+        numTurns: null,
+        durationMs: new Date(completedAt).getTime() - new Date(startedAt).getTime(),
+        timestamp: completedAt,
+        providerType: "opencode",
+        sessionId: resolvedSessionId,
+        messageId: null,
+        eventId: null,
+        turnId: null,
+        parentToolCallId: null,
+        raw: {},
+      });
+    } catch {
+      // A host event handler cannot fail the execution.
+    }
+  }
+
   if (status === "completed") {
     ctx.onLifecycle?.({ phase: "completed" });
   } else if (status === "aborted") {
@@ -248,4 +297,7 @@ export async function executeOpenCodeProvider(ctx: ExecutionContext): Promise<Ex
     raw: null,
     workspace,
   };
+  } finally {
+    await skillConfig.cleanup();
+  }
 }

package/src/providers/opencode/history.ts

@@ -0,0 +1,270 @@
+import type {
+  AttachOptions,
+  HistoryAttachment,
+  HistoryCatchUpOptions,
+  HistoryCatchUpYield,
+  HistoryCheckpoint,
+  LastTurnStatus,
+  SessionRecord,
+  StreamEvent,
+} from "../../types.js";
+import { assertSessionRecord, createSessionRecord, MalformedSessionRecordError } from "../../sessions/record.js";
+import { acquireOpenCodeRuntime } from "./runtime.js";
+import { opencodeSessionCodec } from "./codec.js";
+import { createOpenCodeSession } from "./http-session.js";
+import { mapOpenCodePart, mapOpenCodeToolCall, type OcBaseInfo } from "./event-parse.js";
+
+const PAGE_SIZE = 100;
+const MAX_PAGES = 100;
+const MAX_MESSAGES = 10_000;
+const MAX_BYTES = 25 * 1024 * 1024;
+const CHECKPOINT_KIND = "opencode:message-part:v1";
+
+export class OpenCodeHistoryCheckpointNotFoundError extends Error {
+  readonly code = "history_checkpoint_not_found";
+  constructor() {
+    super("The OpenCode history checkpoint is no longer present");
+    this.name = "OpenCodeHistoryCheckpointNotFoundError";
+  }
+}
+
+export class OpenCodeHistoryResyncLimitError extends Error {
+  readonly code = "history_resync_limit";
+  constructor() {
+    super("OpenCode history exceeded the bounded resync limit");
+    this.name = "OpenCodeHistoryResyncLimitError";
+  }
+}
+
+interface DecodedCheckpoint {
+  messageId: string;
+  partId: string;
+  ordinal: number | null;
+}
+
+export interface MessageEnvelope {
+  info?: Record<string, unknown>;
+  parts?: unknown[];
+}
+
+function rec(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function string(value: unknown): string | null {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+function decodeCheckpoint(checkpoint: HistoryCheckpoint | undefined): DecodedCheckpoint | null {
+  if (!checkpoint) return null;
+  if (checkpoint.kind !== CHECKPOINT_KIND) throw new OpenCodeHistoryCheckpointNotFoundError();
+  const value = rec(checkpoint.value);
+  const messageId = string(value?.["messageId"]);
+  const partId = string(value?.["partId"]);
+  if (!messageId || !partId) throw new OpenCodeHistoryCheckpointNotFoundError();
+  const ordinal = typeof value?.["ordinal"] === "number" && Number.isInteger(value["ordinal"])
+    ? value["ordinal"] as number
+    : null;
+  return { messageId, partId, ordinal };
+}
+
+function checkpoint(messageId: string, partId: string, ordinal: number): HistoryCheckpoint {
+  return { kind: CHECKPOINT_KIND, value: { messageId, partId, ordinal } };
+}
+
+export function historicalEvents(message: MessageEnvelope, sessionId: string): Array<{ event: StreamEvent; partId: string }> {
+  const info = message.info ?? {};
+  if (info["role"] !== "assistant") return [];
+  const messageId = string(info["id"]);
+  const timestamp = new Date(
+    typeof rec(info["time"])?.["created"] === "number"
+      ? rec(info["time"])!["created"] as number
+      : Date.now(),
+  ).toISOString();
+  const base: OcBaseInfo = { provider: "opencode", sessionId, timestamp };
+  const events: Array<{ event: StreamEvent; partId: string }> = [];
+  for (const rawPart of message.parts ?? []) {
+    const part = rec(rawPart);
+    const partId = string(part?.["id"]);
+    if (!part || !partId) continue;
+    if (part["type"] === "tool") {
+      events.push({ event: mapOpenCodeToolCall(part, base), partId });
+      const result = mapOpenCodePart(part, base);
+      if (result?.type === "tool_result") events.push({ event: result, partId });
+      continue;
+    }
+    const event = mapOpenCodePart(part, base);
+    if (event) events.push({ event, partId });
+  }
+  const lastPartId = events.at(-1)?.partId;
+  if (messageId && lastPartId) {
+    const error = info["error"] != null;
+    events.push({
+      partId: lastPartId,
+      event: {
+        type: "result",
+        text: "",
+        costUsd: typeof info["cost"] === "number" ? info["cost"] : null,
+        isError: error,
+        stopReason: null,
+        terminalReason: error ? "failed" : "completed",
+        numTurns: 1,
+        durationMs: null,
+        timestamp,
+        providerType: "opencode",
+        sessionId,
+        messageId,
+        eventId: `${messageId}:result`,
+        turnId: null,
+        parentToolCallId: null,
+        raw: info,
+      },
+    });
+  }
+  return events;
+}
+
+export async function collectHistory(
+  client: import("./client.js").OpenCodeClient,
+  sessionId: string,
+  options: HistoryCatchUpOptions | undefined,
+): Promise<Array<{ event: StreamEvent; checkpoint: HistoryCheckpoint; eventId: string | null }>> {
+  const after = options?.mode === "bounded_full_resync" ? null : decodeCheckpoint(options?.after);
+  const pages: MessageEnvelope[][] = [];
+  let before: string | null = null;
+  let foundMessage = after === null;
+  let collectedMessages = 0;
+  let collectedBytes = 0;
+
+  for (let pageIndex = 0; pageIndex < MAX_PAGES; pageIndex += 1) {
+    const query = new URLSearchParams({ limit: String(PAGE_SIZE) });
+    if (before) query.set("before", before);
+    const response = await client.request(`/session/${encodeURIComponent(sessionId)}/message?${query}`);
+    if (response.status === 404) return [];
+    if (!response.ok) throw new Error(`OpenCode history request failed (${response.status})`);
+    const text = await response.text();
+    collectedBytes += Buffer.byteLength(text);
+    const parsed = JSON.parse(text) as unknown;
+    const page = Array.isArray(parsed)
+      ? parsed.map((value) => rec(value) as MessageEnvelope).filter(Boolean)
+      : [];
+    collectedMessages += page.length;
+    if (collectedBytes > MAX_BYTES || collectedMessages > MAX_MESSAGES) {
+      throw new OpenCodeHistoryResyncLimitError();
+    }
+    pages.push(page);
+    if (after && page.some((message) => string(message.info?.["id"]) === after.messageId)) {
+      foundMessage = true;
+      break;
+    }
+    if (page.length < PAGE_SIZE) break;
+    const next = response.headers.get("x-next-cursor");
+    if (!next || next === before) break;
+    before = next;
+  }
+
+  if (!foundMessage) throw new OpenCodeHistoryCheckpointNotFoundError();
+  if (pages.length === MAX_PAGES && pages.at(-1)?.length === PAGE_SIZE) {
+    throw new OpenCodeHistoryResyncLimitError();
+  }
+
+  const messages = pages.reverse().flat();
+  const output: Array<{ event: StreamEvent; checkpoint: HistoryCheckpoint; eventId: string | null }> = [];
+  let passedCheckpoint = after === null;
+  let foundPart = after === null;
+  for (const message of messages) {
+    const messageId = string(message.info?.["id"]);
+    if (!messageId) continue;
+    const events = historicalEvents(message, sessionId);
+    const partOrdinals = new Map<string, number>();
+    for (const item of events) {
+      const ordinal = partOrdinals.get(item.partId) ?? 0;
+      partOrdinals.set(item.partId, ordinal + 1);
+      if (!passedCheckpoint) {
+        if (
+          foundPart
+          && after!.ordinal === null
+          && messageId === after!.messageId
+          && item.partId === after!.partId
+        ) {
+          continue;
+        }
+        if (
+          messageId === after!.messageId
+          && item.partId === after!.partId
+          && (after!.ordinal === null || ordinal === after!.ordinal)
+        ) {
+          foundPart = true;
+          continue;
+        }
+        if (foundPart) passedCheckpoint = true;
+        else continue;
+      }
+      output.push({
+        event: item.event,
+        checkpoint: checkpoint(messageId, item.partId, ordinal),
+        eventId: item.event.eventId,
+      });
+    }
+    if (foundPart && messageId === after?.messageId) passedCheckpoint = true;
+  }
+  if (!foundPart) throw new OpenCodeHistoryCheckpointNotFoundError();
+  return output;
+}
+
+export async function attachOpenCodeHistory(
+  record: SessionRecord,
+  opts?: AttachOptions,
+): Promise<HistoryAttachment> {
+  assertSessionRecord(record);
+  if (record.providerType !== "opencode") {
+    throw new MalformedSessionRecordError(
+      `opencode history attach requires providerType "opencode"; got ${JSON.stringify(record.providerType)}`,
+      "providerType",
+    );
+  }
+  const params = opencodeSessionCodec.deserialize(record.params);
+  if (!params) throw new MalformedSessionRecordError("opencode history record has no session id", "params");
+  const sessionId = params["sessionId"] as string;
+  const cwd = typeof params["cwd"] === "string" ? params["cwd"] : record.cwd ?? process.cwd();
+  const runtime = await acquireOpenCodeRuntime({ cwd, env: opts?.env, config: opts?.config });
+  let lastTurn: LastTurnStatus = "unknown";
+  try {
+    const response = await runtime.server.client.request(`/session/${encodeURIComponent(sessionId)}/message?limit=1`);
+    if (response.ok) {
+      const messages = await response.json() as MessageEnvelope[];
+      const info = messages.at(-1)?.info;
+      lastTurn = info
+        ? (info["finish"] && !info["error"] ? "completed" : "interrupted")
+        : "unknown";
+    }
+  } catch {
+    lastTurn = "unknown";
+  }
+  const normalized = createSessionRecord({
+    providerType: "opencode",
+    params: { sessionId, cwd },
+    cwd,
+    displayId: sessionId,
+  });
+  return {
+    record: normalized,
+    historySource: { kind: "service", description: "OpenCode authenticated session message history" },
+    lastTurn,
+    catchUp(options) {
+      return {
+        async *[Symbol.asyncIterator](): AsyncIterator<HistoryCatchUpYield> {
+          for (const yielded of await collectHistory(runtime.server.client, sessionId, options)) yield yielded;
+        },
+      };
+    },
+    resume(ctx) {
+      return createOpenCodeSession({ ...ctx, cwd: ctx?.cwd ?? cwd, sessionParams: params });
+    },
+    async close() {
+      runtime.server.release();
+    },
+  };
+}