@agentex/agent 0.0.24 → 0.0.26

package/src/providers/cursor/parse.ts

@@ -0,0 +1,288 @@
+import type { BaseStreamEventFields, StreamEvent } from "../../types.js";
+
+const PROVIDER_TYPE = "cursor";
+
+function stubBase(event: Record<string, unknown>, sessionId: string | null = null): BaseStreamEventFields {
+  return {
+    timestamp: new Date().toISOString(),
+    providerType: PROVIDER_TYPE,
+    sessionId,
+    messageId: null,
+    eventId: null,
+    turnId: null,
+    parentToolCallId: null,
+    raw: event,
+  };
+}
+
+export interface CursorParsedResult {
+  sessionId: string | null;
+  model: string | null;
+  usage: { inputTokens: number; outputTokens: number; cachedInputTokens: number } | null;
+  costUsd: number | null;
+  summary: string | null;
+  isError: boolean;
+  errorMessage: string | null;
+}
+
+function parseJson(line: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    // Skip malformed lines
+  }
+  return null;
+}
+
+function asString(value: unknown, fallback: string): string {
+  return typeof value === "string" ? value : fallback;
+}
+
+function asNumber(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function parseObject(value: unknown): Record<string, unknown> {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  return {};
+}
+
+function readSessionId(event: Record<string, unknown>): string | null {
+  return (
+    asString(event["session_id"], "").trim() ||
+    asString(event["sessionId"], "").trim() ||
+    asString(event["sessionID"], "").trim() ||
+    null
+  );
+}
+
+function collectAssistantText(message: unknown): string[] {
+  if (typeof message === "string") {
+    const trimmed = message.trim();
+    return trimmed ? [trimmed] : [];
+  }
+
+  const rec = parseObject(message);
+  const direct = asString(rec["text"], "").trim();
+  const lines: string[] = direct ? [direct] : [];
+  const content = Array.isArray(rec["content"]) ? rec["content"] : [];
+
+  for (const partRaw of content) {
+    const part = parseObject(partRaw);
+    const type = asString(part["type"], "").trim();
+    if (type === "output_text" || type === "text") {
+      const text = asString(part["text"], "").trim();
+      if (text) lines.push(text);
+    }
+  }
+
+  return lines;
+}
+
+/**
+ * Normalize Cursor stream lines which may have a "stdout: {...}" or "stderr: {...}" prefix.
+ */
+export function normalizeCursorStreamLine(rawLine: string): {
+  stream: "stdout" | "stderr" | null;
+  line: string;
+} {
+  const trimmed = rawLine.trim();
+  if (!trimmed) return { stream: null, line: "" };
+
+  const prefixed = trimmed.match(/^(stdout|stderr)\s*[:=]?\s*([\[{].*)$/i);
+  if (!prefixed) {
+    return { stream: null, line: trimmed };
+  }
+
+  const stream = prefixed[1]?.toLowerCase() === "stderr" ? "stderr" : "stdout";
+  const line = (prefixed[2] ?? "").trim();
+  return { stream, line };
+}
+
+export function parseCursorJsonl(stdout: string): CursorParsedResult {
+  let sessionId: string | null = null;
+  let model: string | null = null;
+  const messages: string[] = [];
+  let errorMessage: string | null = null;
+  let totalCostUsd = 0;
+  const usage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0 };
+  let hasUsage = false;
+
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = normalizeCursorStreamLine(rawLine).line;
+    if (!line) continue;
+
+    const event = parseJson(line);
+    if (!event) continue;
+
+    const foundSession = readSessionId(event);
+    if (foundSession) sessionId = foundSession;
+
+    const type = asString(event["type"], "").trim();
+
+    if (type === "system" && asString(event["subtype"], "").trim() === "init") {
+      model = asString(event["model"], "").trim() || model;
+      continue;
+    }
+
+    if (type === "assistant") {
+      messages.push(...collectAssistantText(event["message"]));
+      continue;
+    }
+
+    if (type === "result") {
+      const usageObj = parseObject(event["usage"]);
+      usage.inputTokens += asNumber(usageObj["input_tokens"], asNumber(usageObj["inputTokens"], 0));
+      usage.cachedInputTokens += asNumber(usageObj["cached_input_tokens"], asNumber(usageObj["cachedInputTokens"], asNumber(usageObj["cache_read_input_tokens"], 0)));
+      usage.outputTokens += asNumber(usageObj["output_tokens"], asNumber(usageObj["outputTokens"], 0));
+      hasUsage = true;
+      totalCostUsd += asNumber(event["total_cost_usd"], asNumber(event["cost_usd"], asNumber(event["cost"], 0)));
+      model = asString(event["model"], "").trim() || model;
+
+      const isError = event["is_error"] === true || asString(event["subtype"], "").toLowerCase() === "error";
+      const resultText = asString(event["result"], "").trim();
+      if (resultText && messages.length === 0) messages.push(resultText);
+      if (isError) {
+        const text = asString(event["error"] as string ?? event["message"] as string ?? event["result"] as string, "").trim();
+        if (text) errorMessage = text;
+      }
+      continue;
+    }
+
+    if (type === "error") {
+      const msg = asString(event["message"] as string ?? event["error"] as string, "").trim();
+      if (msg) errorMessage = msg;
+      continue;
+    }
+
+    if (type === "system") {
+      const subtype = asString(event["subtype"], "").trim().toLowerCase();
+      if (subtype === "error") {
+        const msg = asString(event["message"] as string ?? event["error"] as string, "").trim();
+        if (msg) errorMessage = msg;
+      }
+      continue;
+    }
+
+    if (type === "text") {
+      const part = parseObject(event["part"]);
+      const text = asString(part["text"], "").trim();
+      if (text) messages.push(text);
+      continue;
+    }
+
+    if (type === "step_finish") {
+      const part = parseObject(event["part"]);
+      const tokens = parseObject(part["tokens"]);
+      const cache = parseObject(tokens["cache"]);
+      usage.inputTokens += asNumber(tokens["input"], 0);
+      usage.cachedInputTokens += asNumber(cache["read"], 0);
+      usage.outputTokens += asNumber(tokens["output"], 0);
+      hasUsage = true;
+      totalCostUsd += asNumber(part["cost"], 0);
+      continue;
+    }
+  }
+
+  return {
+    sessionId,
+    model,
+    usage: hasUsage ? usage : null,
+    costUsd: totalCostUsd > 0 ? totalCostUsd : null,
+    summary: messages.join("\n\n").trim() || null,
+    isError: errorMessage !== null,
+    errorMessage,
+  };
+}
+
+export function parseCursorStreamLine(line: string): StreamEvent | null {
+  const normalized = normalizeCursorStreamLine(line);
+  if (!normalized.line) return null;
+
+  const event = parseJson(normalized.line);
+  if (!event) return null;
+
+  const type = asString(event["type"], "").trim();
+  const sessionId = readSessionId(event);
+  const base = stubBase(event, sessionId);
+
+  if (type === "system" && asString(event["subtype"], "").trim() === "init") {
+    return {
+      type: "system",
+      subtype: "init",
+      model: asString(event["model"], "") || null,
+      cwd: null,
+      tools: null,
+      permissionMode: null,
+      ...base,
+    };
+  }
+
+  if (type === "assistant") {
+    const message = parseObject(event["message"]);
+    const content = Array.isArray(message["content"]) ? message["content"] : [];
+    for (const partRaw of content) {
+      const part = parseObject(partRaw);
+      const blockType = asString(part["type"], "").trim();
+      if (blockType === "tool_use") {
+        return {
+          type: "tool_call",
+          toolCallId: asString(part["id"], "") || null,
+          name: asString(part["name"], ""),
+          input: part["input"],
+          ...base,
+        };
+      }
+      if (blockType === "tool_result") {
+        return {
+          type: "tool_result",
+          toolCallId: asString(part["tool_use_id"], "") || null,
+          toolName: null,
+          content: asString(part["content"], ""),
+          isError: part["is_error"] === true,
+          exitCode: null,
+          ...base,
+        };
+      }
+    }
+
+    const texts = collectAssistantText(event["message"]);
+    if (texts.length > 0) {
+      return { type: "assistant", text: texts.join("\n"), ...base };
+    }
+  }
+
+  if (type === "result") {
+    return {
+      type: "result",
+      text: asString(event["result"], ""),
+      costUsd: typeof event["total_cost_usd"] === "number" ? event["total_cost_usd"] : null,
+      isError: event["is_error"] === true,
+      stopReason: null,
+      terminalReason: null,
+      numTurns: null,
+      durationMs: null,
+      ...base,
+    };
+  }
+
+  // Forward-compat: surface unknown wire events rather than dropping them.
+  return { type: "unknown", subtype: type, ...base };
+}
+
+const CURSOR_UNKNOWN_SESSION_RE = /unknown\s+(session|chat)|session\s+.*\s+not\s+found|chat\s+.*\s+not\s+found|resume\s+.*\s+not\s+found|could\s+not\s+resume/i;
+
+export function isCursorUnknownSessionError(stdout: string, stderr: string): boolean {
+  return CURSOR_UNKNOWN_SESSION_RE.test(stdout) || CURSOR_UNKNOWN_SESSION_RE.test(stderr);
+}
+
+const CURSOR_AUTH_RE = /CURSOR_API_KEY\s+is\s+not\s+set|OPENAI_API_KEY\s+is\s+not\s+set|unauthorized|authentication.*required/i;
+
+export function isCursorAuthRequired(stdout: string, stderr: string): boolean {
+  return CURSOR_AUTH_RE.test(stdout) || CURSOR_AUTH_RE.test(stderr);
+}

package/src/providers/gemini/index.ts

@@ -0,0 +1,21 @@
+import type { ProviderModule } from "../../types.js";
+import { acpProvider } from "../acp/index.js";
+import { resolveAuthForProvider } from "../../utils/auth.js";
+
+/**
+ * Gemini via the Agent Client Protocol (`gemini --acp`). Requires a recent
+ * `@google/gemini-cli` on PATH; Gemini handles its own Google auth (GEMINI_API_KEY,
+ * GOOGLE_API_KEY, or an OAuth login).
+ *
+ * Replaces the previous one-shot `--output-format stream-json` adapter: the ACP
+ * base gives gemini real sessions, streaming, tool-call correlation, permission
+ * bridging (via `onUserInputRequest`), and mode discovery — none of which the
+ * stub parser had.
+ */
+const gemini: ProviderModule = acpProvider({ id: "gemini", command: ["gemini", "--acp"] });
+
+// Keep gemini's richer auth reporting (API key / OAuth presence) rather than the
+// generic ACP binary-only check.
+gemini.resolveAuth = (ctx) => resolveAuthForProvider("gemini", ctx);
+
+export const geminiProvider = gemini;

package/src/providers/openclaw/codec.ts

@@ -0,0 +1,40 @@
+import type { SessionCodec } from "../../types.js";
+
+function readNonEmptyString(value: unknown): string | null {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function parseAsObject(raw: unknown): Record<string, unknown> | null {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+  return raw as Record<string, unknown>;
+}
+
+export const openclawSessionCodec: SessionCodec = {
+  deserialize(raw: unknown): Record<string, unknown> | null {
+    const obj = parseAsObject(raw);
+    if (!obj) return null;
+    const sessionKey = readNonEmptyString(obj["sessionKey"]) ?? readNonEmptyString(obj["session_key"]);
+    if (!sessionKey) return null;
+    const gatewayUrl = readNonEmptyString(obj["gatewayUrl"]) ?? readNonEmptyString(obj["gateway_url"]);
+    return {
+      sessionKey,
+      ...(gatewayUrl ? { gatewayUrl } : {}),
+    };
+  },
+
+  serialize(params: Record<string, unknown> | null): Record<string, unknown> | null {
+    if (!params) return null;
+    const sessionKey = readNonEmptyString(params["sessionKey"]) ?? readNonEmptyString(params["session_key"]);
+    if (!sessionKey) return null;
+    const gatewayUrl = readNonEmptyString(params["gatewayUrl"]);
+    return {
+      sessionKey,
+      ...(gatewayUrl ? { gatewayUrl } : {}),
+    };
+  },
+
+  getDisplayId(params: Record<string, unknown> | null): string | null {
+    if (!params) return null;
+    return readNonEmptyString(params["sessionKey"]) ?? readNonEmptyString(params["session_key"]);
+  },
+};

package/src/providers/openclaw/execute.ts

@@ -0,0 +1,19 @@
+import type { ExecutionContext, ExecutionResult } from "../../types.js";
+import { runHttpAgent } from "../_shared/http-agent.js";
+
+/**
+ * OpenClaw is a remote HTTP-gateway agent — its behavior is the canonical
+ * `httpAgent` pattern (URL resolution, sessionKey round-trip, 401/403 →
+ * auth_required, AbortController timeout), so it's a thin call into the shared base.
+ */
+export function executeOpenclawProvider(ctx: ExecutionContext): Promise<ExecutionResult> {
+  return runHttpAgent(
+    {
+      providerType: "openclaw",
+      defaultBaseUrl: "http://localhost:3001",
+      runPath: "/api/agent/run",
+      loginCommand: "openclaw login",
+    },
+    ctx,
+  );
+}

package/src/providers/openclaw/index.ts

@@ -0,0 +1,29 @@
+import type { ProviderModule } from "../../types.js";
+import { openclawSessionCodec } from "./codec.js";
+
+export const openclawProvider: ProviderModule = {
+  type: "openclaw",
+  capabilities: {
+    sessions: false,
+    modelDiscovery: false,
+    quotaProbing: false,
+    mcp: false,
+    skills: false,
+    instructions: false,
+    workspace: false,
+    planMode: false,
+    concurrentSend: false,
+    cancelQueuedMessage: false,
+    stopTask: false,
+    modes: false,
+  },
+  // execute.ts loads lazily on first use.
+  execute: async (ctx) => (await import("./execute.js")).executeOpenclawProvider(ctx),
+  resolveAuth: async () => ({
+    providerType: "openclaw",
+    binary: { installed: true }, // openclaw is a gateway URL, not a local binary
+    options: [],
+    source: "filesystem",
+  }),
+  sessionCodec: openclawSessionCodec,
+};

package/src/providers/opencode/codec.ts

@@ -0,0 +1,50 @@
+import type { SessionCodec } from "../../types.js";
+
+function readNonEmptyString(value: unknown): string | null {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function parseAsObject(raw: unknown): Record<string, unknown> | null {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+  return raw as Record<string, unknown>;
+}
+
+export const opencodeSessionCodec: SessionCodec = {
+  deserialize(raw: unknown): Record<string, unknown> | null {
+    const obj = parseAsObject(raw);
+    if (!obj) return null;
+    const sessionId =
+      readNonEmptyString(obj["sessionId"]) ??
+      readNonEmptyString(obj["session_id"]) ??
+      readNonEmptyString(obj["sessionID"]);
+    if (!sessionId) return null;
+    const cwd = readNonEmptyString(obj["cwd"]);
+    return {
+      sessionId,
+      ...(cwd ? { cwd } : {}),
+    };
+  },
+
+  serialize(params: Record<string, unknown> | null): Record<string, unknown> | null {
+    if (!params) return null;
+    const sessionId =
+      readNonEmptyString(params["sessionId"]) ??
+      readNonEmptyString(params["session_id"]) ??
+      readNonEmptyString(params["sessionID"]);
+    if (!sessionId) return null;
+    const cwd = readNonEmptyString(params["cwd"]);
+    return {
+      sessionId,
+      ...(cwd ? { cwd } : {}),
+    };
+  },
+
+  getDisplayId(params: Record<string, unknown> | null): string | null {
+    if (!params) return null;
+    return (
+      readNonEmptyString(params["sessionId"]) ??
+      readNonEmptyString(params["session_id"]) ??
+      readNonEmptyString(params["sessionID"])
+    );
+  },
+};

package/src/providers/opencode/event-parse.ts

@@ -0,0 +1,141 @@
+import type { BaseStreamEventFields, StreamEvent, TokenUsage } from "../../types.js";
+
+function str(v: unknown): string | null {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function num(v: unknown): number | null {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function rec(v: unknown): Record<string, unknown> | null {
+  return v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : null;
+}
+
+export interface OcBaseInfo {
+  provider: string;
+  sessionId: string | null;
+  timestamp: string;
+}
+
+function makeBase(raw: Record<string, unknown>, info: OcBaseInfo): BaseStreamEventFields {
+  return {
+    timestamp: info.timestamp,
+    providerType: info.provider,
+    sessionId: info.sessionId,
+    messageId: str(raw["messageID"]),
+    eventId: str(raw["id"]),
+    turnId: null,
+    parentToolCallId: null,
+    raw,
+  };
+}
+
+/** True if a text part should be surfaced (skip synthetic / ignored parts). */
+function isVisibleText(part: Record<string, unknown>): boolean {
+  return part["synthetic"] !== true && part["ignored"] !== true;
+}
+
+/** Concatenate the visible assistant text across a message's parts. */
+export function assistantTextFromParts(parts: unknown): string {
+  if (!Array.isArray(parts)) return "";
+  const out: string[] = [];
+  for (const p of parts) {
+    const part = rec(p);
+    if (!part) continue;
+    if (part["type"] === "text" && isVisibleText(part) && typeof part["text"] === "string") {
+      out.push(part["text"]);
+    }
+  }
+  return out.join("");
+}
+
+/** Status of an opencode AssistantMessage → TurnResult status. */
+export function turnStatusFromMessage(info: unknown): "completed" | "failed" {
+  const m = rec(info);
+  return m && m["error"] ? "failed" : "completed";
+}
+
+/** Map opencode's `tokens` (+ model identity) to agentex usage. */
+export function usageFromMessage(info: unknown): Record<string, TokenUsage> | undefined {
+  const m = rec(info);
+  if (!m) return undefined;
+  const tokens = rec(m["tokens"]);
+  if (!tokens) return undefined;
+  const input = num(tokens["input"]);
+  const output = num(tokens["output"]);
+  if (input == null && output == null) return undefined;
+  const cache = rec(tokens["cache"]);
+  const model =
+    [str(m["providerID"]), str(m["modelID"])].filter(Boolean).join("/") || "opencode";
+  const usage: TokenUsage = { inputTokens: input ?? 0, outputTokens: output ?? 0 };
+  const cacheRead = cache ? num(cache["read"]) : null;
+  if (cacheRead != null) usage.cachedInputTokens = cacheRead;
+  return { [model]: usage };
+}
+
+/** Build a `tool_call` StreamEvent for an opencode ToolPart (the announcement,
+ *  emitted on first sight regardless of state). */
+export function mapOpenCodeToolCall(part: Record<string, unknown>, info: OcBaseInfo): StreamEvent {
+  const state = rec(part["state"]);
+  return {
+    type: "tool_call",
+    toolCallId: str(part["callID"]),
+    name: str(part["tool"]) ?? "tool",
+    input: state ? (state["input"] ?? null) : null,
+    ...makeBase(part, info),
+  };
+}
+
+/**
+ * Map an opencode `Part` to a StreamEvent. Text/reasoning parts carry the text
+ * to emit in `textOverride` (the session passes a computed delta so streaming
+ * isn't re-emitted in full). Tool parts map by their state status. Returns null
+ * for parts with no agentex equivalent.
+ */
+export function mapOpenCodePart(
+  part: Record<string, unknown>,
+  info: OcBaseInfo,
+  textOverride?: string,
+): StreamEvent | null {
+  const base = makeBase(part, info);
+  const type = part["type"];
+
+  if (type === "text") {
+    if (!isVisibleText(part)) return null;
+    const text = textOverride ?? (typeof part["text"] === "string" ? part["text"] : "");
+    return text ? { type: "assistant", text, ...base } : null;
+  }
+  if (type === "reasoning") {
+    const text = textOverride ?? (typeof part["text"] === "string" ? part["text"] : "");
+    return text ? { type: "thinking", text, ...base } : null;
+  }
+  if (type === "tool") {
+    const state = rec(part["state"]);
+    const status = state ? str(state["status"]) : null;
+    const callId = str(part["callID"]);
+    const name = str(part["tool"]) ?? "tool";
+    if (status === "completed" || status === "error") {
+      // OpenCode's ToolState carries the result in `output` on completion and the
+      // message in `error` on failure (verified against the 1.3.x OpenAPI).
+      const raw = status === "error" ? state?.["error"] : state?.["output"];
+      const content = typeof raw === "string" ? raw : raw != null ? JSON.stringify(raw) : "";
+      return {
+        type: "tool_result",
+        toolCallId: callId,
+        toolName: name,
+        content,
+        isError: status === "error",
+        exitCode: null,
+        ...base,
+      };
+    }
+    // pending / running → the tool_call announcement
+    return {
+      type: "tool_call",
+      toolCallId: callId,
+      name,
+      input: state ? (state["input"] ?? null) : null,
+      ...base,
+    };
+  }
+  return null;
+}