@m8tes/sdk 0.1.0-alpha.1

package/dist/chunk-UFQQNUFE.js

@@ -0,0 +1,1083 @@
+// src/protocol/events.ts
+var PROTOCOL_VERSION = "m8tes.stream.v2";
+var TERMINAL_EVENT_TYPES = [
+  "run-finish",
+  "run-error",
+  "run-cancelled"
+];
+function isTerminalEvent(event) {
+  return TERMINAL_EVENT_TYPES.includes(event.type);
+}
+
+// src/protocol/sse-parser.ts
+function splitConcatenatedJson(payload) {
+  const out = [];
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let start = -1;
+  let lastEnd = 0;
+  for (let i = 0; i < payload.length; i++) {
+    const ch = payload.charAt(i);
+    if (start === -1) {
+      if (ch === "{" || ch === "[") {
+        start = i;
+        depth = 1;
+        inString = false;
+        escaped = false;
+      }
+      continue;
+    }
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{" || ch === "[") {
+      depth++;
+    } else if (ch === "}" || ch === "]") {
+      depth--;
+      if (depth === 0) {
+        out.push(payload.slice(start, i + 1));
+        start = -1;
+        lastEnd = i + 1;
+      }
+    }
+  }
+  if (start !== -1) {
+    out.push(payload.slice(start));
+  } else {
+    const tail = payload.slice(lastEnd).trim();
+    if (tail !== "") out.push(tail);
+  }
+  return out;
+}
+function frameDataPayload(frameText) {
+  const dataLines = [];
+  for (const rawLine of frameText.split("\n")) {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (line === "" || line.charAt(0) === ":") continue;
+    if (line.startsWith("data:")) {
+      let value = line.slice(5);
+      if (value.charAt(0) === " ") value = value.slice(1);
+      dataLines.push(value);
+    }
+  }
+  if (dataLines.length === 0) return null;
+  return dataLines.join("\n");
+}
+function parsePayload(payload, onMalformed) {
+  const out = [];
+  for (const candidate of splitConcatenatedJson(payload)) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        out.push(parsed);
+      } else {
+        onMalformed?.(candidate, new Error("frame is not a JSON object"));
+      }
+    } catch (err) {
+      onMalformed?.(candidate, err);
+    }
+  }
+  return out;
+}
+function createSseDecoder(opts = {}) {
+  let buf = "";
+  function ingest(chunk) {
+    buf += chunk;
+    let tail = "";
+    if (buf.endsWith("\r")) {
+      tail = "\r";
+      buf = buf.slice(0, -1);
+    }
+    buf = buf.replace(/\r\n?/g, "\n") + tail;
+  }
+  function drain(final) {
+    const frames = [];
+    let sep = buf.indexOf("\n\n");
+    while (sep !== -1) {
+      const frameText = buf.slice(0, sep);
+      buf = buf.slice(sep + 2);
+      const payload = frameDataPayload(frameText);
+      if (payload !== null) frames.push(...parsePayload(payload, opts.onMalformed));
+      sep = buf.indexOf("\n\n");
+    }
+    if (final && buf.trim() !== "") {
+      const payload = frameDataPayload(buf);
+      if (payload !== null) frames.push(...parsePayload(payload, opts.onMalformed));
+      buf = "";
+    }
+    return frames;
+  }
+  return {
+    /** Feed a chunk; returns the wire frames it completed. */
+    push(chunk) {
+      ingest(chunk);
+      return drain(false);
+    },
+    /** Flush a trailing unterminated frame at end-of-stream. */
+    flush() {
+      if (buf.endsWith("\r")) buf = `${buf.slice(0, -1)}
+`;
+      return drain(true);
+    }
+  };
+}
+function parseSse(text, opts = {}) {
+  const dec = createSseDecoder(opts);
+  return [...dec.push(text), ...dec.flush()];
+}
+
+// src/protocol/normalizer.ts
+var ASK_USER_QUESTION = "AskUserQuestion";
+var SANDBOX_ERROR_CODES = /* @__PURE__ */ new Set([
+  "SANDBOX_BOOT_TIMEOUT",
+  "SANDBOX_QUOTA_EXHAUSTED",
+  "SANDBOX_UNAVAILABLE",
+  "SNAPSHOT_VERSION_MISMATCH",
+  "AGENT_RUNNER_DIED",
+  "RUNNER_LIFECYCLE_ERROR"
+]);
+var str = (o, k) => typeof o[k] === "string" ? o[k] : void 0;
+var num = (o, k) => typeof o[k] === "number" ? o[k] : void 0;
+var bool = (o, k) => typeof o[k] === "boolean" ? o[k] : void 0;
+var obj = (o, k) => {
+  const v = o[k];
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+};
+var arr = (o, k) => Array.isArray(o[k]) ? o[k] : void 0;
+function blockKindFromType(t) {
+  switch (t) {
+    case "text":
+      return "text";
+    case "thinking":
+    case "reasoning":
+      return "reasoning";
+    case "plan":
+      return "plan";
+    case "tool_use":
+    case "server_tool_use":
+      return "tool_use";
+    default:
+      return "other";
+  }
+}
+var blockEndType = {
+  text: "text-end",
+  reasoning: "reasoning-end",
+  plan: "plan-end"
+};
+var blockStartType = {
+  text: "text-start",
+  reasoning: "reasoning-start",
+  plan: "plan-start"
+};
+var blockDeltaType = {
+  text: "text-delta",
+  reasoning: "reasoning-delta",
+  plan: "plan-delta"
+};
+function createNormalizer() {
+  let seq = 0;
+  let open = /* @__PURE__ */ new Set();
+  let seen = /* @__PURE__ */ new Set();
+  let blockKind = /* @__PURE__ */ new Map();
+  let currentMessageId = null;
+  let activeTextBlockId = null;
+  let lastToolId = null;
+  let lastQuestionToolId = null;
+  let anyContentStreamed = false;
+  let runStartEmitted = false;
+  let terminalEmitted = false;
+  function reset() {
+    seq = 0;
+    open = /* @__PURE__ */ new Set();
+    seen = /* @__PURE__ */ new Set();
+    blockKind = /* @__PURE__ */ new Map();
+    currentMessageId = null;
+    activeTextBlockId = null;
+    lastToolId = null;
+    lastQuestionToolId = null;
+    anyContentStreamed = false;
+    runStartEmitted = false;
+    terminalEmitted = false;
+  }
+  function emitContentBlockStart(f, out) {
+    const id = str(f, "id");
+    if (!id) return;
+    const kind = blockKindFromType(str(f, "block_type") ?? str(f, "type"));
+    const key = kind === "tool_use" ? `tool:${id}` : `block:${id}`;
+    if (open.has(key) || seen.has(key)) return;
+    blockKind.set(id, kind);
+    if (kind === "tool_use") {
+      const name = str(f, "name") ?? "";
+      if (name === ASK_USER_QUESTION) lastQuestionToolId = id;
+      else lastToolId = id;
+      open.add(key);
+      out.push({
+        type: "tool-input-start",
+        toolCallId: id,
+        toolName: name,
+        messageId: currentMessageId ?? "",
+        state: "input-streaming"
+      });
+    } else if (kind === "text" || kind === "reasoning" || kind === "plan") {
+      open.add(key);
+      if (kind === "text") activeTextBlockId = id;
+      anyContentStreamed = true;
+      out.push({
+        type: blockStartType[kind],
+        id,
+        messageId: currentMessageId ?? ""
+      });
+    }
+  }
+  function emitContentBlockDelta(f, out) {
+    const id = str(f, "id");
+    if (!id) return;
+    const delta = obj(f, "delta");
+    if (!delta) return;
+    const dType = str(delta, "type");
+    if (dType === "input_json_delta") {
+      const key2 = `tool:${id}`;
+      if (seen.has(key2)) return;
+      const partial = str(delta, "partial_json") ?? "";
+      if (partial === "") return;
+      if (!open.has(key2)) {
+        open.add(key2);
+        blockKind.set(id, "tool_use");
+      }
+      out.push({
+        type: "tool-input-delta",
+        toolCallId: id,
+        inputTextDelta: partial,
+        state: "input-streaming"
+      });
+      return;
+    }
+    let kind = null;
+    if (dType === "text_delta") kind = "text";
+    else if (dType === "thinking_delta" || dType === "reasoning_delta")
+      kind = "reasoning";
+    else if (dType === "plan_delta") kind = "plan";
+    if (!kind) return;
+    const key = `block:${id}`;
+    if (seen.has(key)) return;
+    const text = kind === "reasoning" ? str(delta, "thinking") ?? str(delta, "text") ?? "" : kind === "plan" ? str(delta, "text") ?? str(delta, "plan") ?? "" : str(delta, "text") ?? "";
+    if (text === "") return;
+    if (!open.has(key)) {
+      open.add(key);
+      blockKind.set(id, kind);
+      if (kind === "text") activeTextBlockId = id;
+      anyContentStreamed = true;
+    }
+    out.push({ type: blockDeltaType[kind], id, delta: text, messageId: currentMessageId ?? "" });
+  }
+  function emitContentBlockStop(f, out) {
+    const id = str(f, "id");
+    if (!id) return;
+    const kind = blockKind.get(id) ?? "other";
+    if (kind === "tool_use") {
+      seen.add(`tool:${id}`);
+      open.delete(`tool:${id}`);
+      return;
+    }
+    if (kind === "text" || kind === "reasoning" || kind === "plan") {
+      const key = `block:${id}`;
+      open.delete(key);
+      if (seen.has(key)) return;
+      seen.add(key);
+      if (activeTextBlockId === id) activeTextBlockId = null;
+      out.push({ type: blockEndType[kind], id, messageId: currentMessageId ?? "" });
+    }
+  }
+  function emitMessageDelta(f, out) {
+    const delta = obj(f, "delta");
+    if (!delta) return;
+    const text = str(delta, "text") ?? "";
+    if (text === "" || !activeTextBlockId) return;
+    const key = `block:${activeTextBlockId}`;
+    if (seen.has(key)) return;
+    out.push({
+      type: "text-delta",
+      id: activeTextBlockId,
+      delta: text,
+      messageId: currentMessageId ?? ""
+    });
+  }
+  function emitStandaloneToolUse(f, out) {
+    const id = str(f, "id");
+    if (!id) return;
+    const name = str(f, "name") ?? "";
+    if (name === ASK_USER_QUESTION) lastQuestionToolId = id;
+    else if (name) lastToolId = id;
+    if ("input" in f) {
+      const key = `toolinput:${id}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      out.push({
+        type: "tool-input-available",
+        toolCallId: id,
+        toolName: name,
+        input: f["input"],
+        state: "input-available"
+      });
+    } else {
+      const partial = str(f, "input_text");
+      if (partial && !seen.has(`tool:${id}`)) {
+        out.push({
+          type: "tool-input-delta",
+          toolCallId: id,
+          inputTextDelta: partial,
+          state: "input-streaming"
+        });
+      }
+    }
+  }
+  function emitToolResult(f, out) {
+    const id = str(f, "tool_use_id");
+    if (!id) return;
+    const key = `tool_result:${id}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    const isError = bool(f, "is_error") ?? false;
+    const output = "content" in f ? f["content"] : f["result"];
+    out.push({
+      type: "tool-output-available",
+      toolCallId: id,
+      output,
+      isError,
+      state: isError ? "output-error" : "output-available"
+    });
+  }
+  function emitApprovalGate(f, out) {
+    const requestId = str(f, "request_id");
+    if (!requestId) return;
+    const toolName = str(f, "tool_name") ?? "";
+    const timeoutSeconds = num(f, "timeout_seconds") ?? 0;
+    const toolInput = f["tool_input"];
+    if (toolName === ASK_USER_QUESTION) {
+      const key = `question:${requestId}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      const ti = obj(f, "tool_input");
+      const questions = ((ti && arr(ti, "questions")) ?? []).flatMap((q) => {
+        if (q === null || typeof q !== "object") return [];
+        const qq = q;
+        const options = (arr(qq, "options") ?? []).flatMap((o) => {
+          if (typeof o === "string") return [{ label: o }];
+          if (o === null || typeof o !== "object") return [];
+          const label = str(o, "label");
+          if (!label) return [];
+          const description = str(o, "description");
+          return [description === void 0 ? { label } : { label, description }];
+        });
+        return [{ ...qq, question: str(qq, "question") ?? "", options }];
+      });
+      out.push({
+        type: "question",
+        requestId,
+        toolCallId: str(f, "tool_use_id") ?? lastQuestionToolId ?? "",
+        questions,
+        timeoutSeconds
+      });
+    } else {
+      const key = `approval:${requestId}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      out.push({
+        type: "approval-request",
+        requestId,
+        // The frame's own tool_use_id is authoritative (live awaiting_approval
+        // carries it; rejoin permission_request does too as of the run_join
+        // fix). The last-tool inference is only a fallback — with PARALLEL tool
+        // calls it can name the wrong tool.
+        toolCallId: str(f, "tool_use_id") ?? lastToolId ?? void 0,
+        toolName,
+        toolInput,
+        timeoutSeconds
+      });
+    }
+  }
+  function emitSnapshot(f, out) {
+    const messageId = str(f, "message_id") ?? currentMessageId ?? "";
+    const blocks = arr(f, "content_blocks") ?? [];
+    for (let i = 0; i < blocks.length; i++) {
+      const raw = blocks[i];
+      if (raw === null || typeof raw !== "object") continue;
+      const b = raw;
+      const bType = str(b, "type");
+      const kind = blockKindFromType(bType);
+      if (kind === "text" || kind === "reasoning" || kind === "plan") {
+        let id = str(b, "id");
+        if (!id) {
+          if (anyContentStreamed) continue;
+          id = `${messageId}:snap:${i}`;
+        }
+        const key = `block:${id}`;
+        if (seen.has(key)) continue;
+        if (open.has(key)) {
+          open.delete(key);
+          seen.add(key);
+          if (activeTextBlockId === id) activeTextBlockId = null;
+          out.push({ type: blockEndType[kind], id, messageId });
+          continue;
+        }
+        seen.add(key);
+        out.push({ type: blockStartType[kind], id, messageId });
+        const text = kind === "reasoning" ? str(b, "thinking") ?? str(b, "text") ?? "" : kind === "plan" ? str(b, "plan") ?? str(b, "text") ?? "" : str(b, "text") ?? "";
+        if (text !== "") out.push({ type: blockDeltaType[kind], id, delta: text, messageId });
+        out.push({ type: blockEndType[kind], id, messageId });
+      } else if (bType === "tool_use") {
+        const id = str(b, "id");
+        if (!id || seen.has(`toolinput:${id}`)) continue;
+        seen.add(`toolinput:${id}`);
+        out.push({
+          type: "tool-input-available",
+          toolCallId: id,
+          toolName: str(b, "name") ?? "",
+          input: b["input"],
+          state: "input-available"
+        });
+      } else if (bType === "tool_result") {
+        const id = str(b, "tool_use_id");
+        if (!id || seen.has(`tool_result:${id}`)) continue;
+        seen.add(`tool_result:${id}`);
+        const isError = bool(b, "is_error") ?? false;
+        out.push({
+          type: "tool-output-available",
+          toolCallId: id,
+          output: "content" in b ? b["content"] : b["result"],
+          isError,
+          state: isError ? "output-error" : "output-available"
+        });
+      }
+    }
+  }
+  function emitNotice(out, level, source, message, detail) {
+    out.push(detail === void 0 ? { type: "notice", level, source, message } : { type: "notice", level, source, message, detail });
+  }
+  function handle(frame, out) {
+    const type = str(frame, "type") ?? "";
+    switch (type) {
+      /* ---- dropped no-ops ---- */
+      case "keep-alive":
+      case "ping":
+      case "RUNNER_DIAG":
+      case "sdk_init":
+      case "sandbox_metrics":
+        return;
+      /* ---- run lifecycle ---- */
+      case "metadata": {
+        if (runStartEmitted) return;
+        runStartEmitted = true;
+        const sandboxId = str(frame, "sandbox_id") ?? null;
+        const sandboxEnabled = bool(frame, "sandbox_enabled") ?? false;
+        out.push({
+          type: "run-start",
+          protocolVersion: PROTOCOL_VERSION,
+          runId: num(frame, "run_id") ?? null,
+          runUuid: str(frame, "run_uuid") ?? null,
+          mode: str(frame, "mode") === "task" ? "task" : "chat",
+          ...str(frame, "agent_name") ? { agentName: str(frame, "agent_name") } : {},
+          ...num(frame, "instance_id") !== void 0 ? { instanceId: num(frame, "instance_id") } : {},
+          ...num(frame, "task_id") !== void 0 ? { taskId: num(frame, "task_id") } : {},
+          ...str(frame, "status") ? { status: str(frame, "status") } : {},
+          sandbox: { id: sandboxId, enabled: sandboxEnabled }
+        });
+        return;
+      }
+      case "run_metrics": {
+        out.push({
+          type: "run-metrics",
+          model: str(frame, "model") ?? "",
+          executionTimeMs: num(frame, "execution_time_ms") ?? 0,
+          inputTokens: num(frame, "input_tokens_used") ?? 0,
+          outputTokens: num(frame, "output_tokens_used") ?? 0,
+          costUsd: num(frame, "claude_token_cost_usd") ?? null,
+          sdkCostUsd: num(frame, "sdk_total_cost_usd") ?? null,
+          stopReason: str(frame, "stop_reason") ?? null,
+          completionState: str(frame, "completion_state") ?? "",
+          unresolvedToolUseIds: (arr(frame, "unresolved_tool_use_ids") ?? []).filter(
+            (x) => typeof x === "string"
+          ),
+          messageCount: num(frame, "message_count") ?? 0,
+          ...obj(frame, "diagnostics") ? { diagnostics: obj(frame, "diagnostics") } : {}
+        });
+        return;
+      }
+      case "done": {
+        if (terminalEmitted) return;
+        terminalEmitted = true;
+        const completionState = str(frame, "completion_state") ?? "complete";
+        out.push({
+          type: "run-finish",
+          status: completionState === "complete" ? "complete" : "incomplete",
+          completionState,
+          unresolvedToolUseIds: (arr(frame, "unresolved_tool_use_ids") ?? []).filter(
+            (x) => typeof x === "string"
+          ),
+          stopReason: str(frame, "stop_reason") ?? null,
+          terminalCompletionSeen: bool(frame, "terminal_completion_seen") ?? false,
+          messageCount: num(frame, "message_count") ?? 0
+        });
+        return;
+      }
+      case "cancelled": {
+        if (terminalEmitted) return;
+        terminalEmitted = true;
+        out.push({ type: "run-cancelled", runId: num(frame, "run_id") ?? null });
+        return;
+      }
+      case "error":
+      case "AGENT_RUNNER_DIED":
+      case "RUNNER_LIFECYCLE_ERROR":
+      case "SANDBOX_BOOT_TIMEOUT":
+      case "SANDBOX_QUOTA_EXHAUSTED":
+      case "SANDBOX_UNAVAILABLE":
+      case "SNAPSHOT_VERSION_MISMATCH": {
+        if (terminalEmitted) return;
+        terminalEmitted = true;
+        const code = SANDBOX_ERROR_CODES.has(type) ? type : null;
+        out.push({
+          type: "run-error",
+          error: str(frame, "error") ?? str(frame, "message") ?? type,
+          message: str(frame, "message") ?? "Agent execution failed",
+          code,
+          fatal: true
+        });
+        return;
+      }
+      case "sdk_error": {
+        emitNotice(out, "warning", "system", str(frame, "error") ?? "SDK error");
+        return;
+      }
+      case "sdk_success": {
+        if (bool(frame, "is_error") !== true) {
+          out.push({ type: "unknown", wireType: type });
+          return;
+        }
+        if (terminalEmitted) return;
+        terminalEmitted = true;
+        out.push({
+          type: "run-error",
+          error: str(frame, "subtype") ?? "sdk_error",
+          message: str(frame, "result") ?? "The model provider returned an error.",
+          code: null,
+          fatal: true
+        });
+        return;
+      }
+      /* ---- message lifecycle ---- */
+      case "message_start": {
+        const msg = obj(frame, "message");
+        const id = (msg && str(msg, "id")) ?? str(frame, "message_id");
+        if (!id) return;
+        currentMessageId = id;
+        const key = `message:${id}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        const usage = msg && obj(msg, "usage");
+        out.push({
+          type: "message-start",
+          messageId: id,
+          role: "assistant",
+          ...usage ? { usage: { inputTokens: num(usage, "input_tokens") ?? 0, outputTokens: num(usage, "output_tokens") ?? 0 } } : {}
+        });
+        return;
+      }
+      case "message_stop":
+      case "message_complete": {
+        const id = str(frame, "message_id") ?? currentMessageId;
+        if (!id) return;
+        const key = `message:${id}:end`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        const usage = obj(frame, "usage");
+        out.push({
+          type: "message-end",
+          messageId: id,
+          ...usage ? { usage: { inputTokens: num(usage, "input_tokens") ?? 0, outputTokens: num(usage, "output_tokens") ?? 0 } } : {}
+        });
+        return;
+      }
+      case "message_snapshot":
+        emitSnapshot(frame, out);
+        return;
+      /* ---- content blocks ---- */
+      case "content_block_start":
+        emitContentBlockStart(frame, out);
+        return;
+      case "content_block_delta":
+        emitContentBlockDelta(frame, out);
+        return;
+      case "content_block_stop":
+        emitContentBlockStop(frame, out);
+        return;
+      case "message_delta":
+        emitMessageDelta(frame, out);
+        return;
+      /* ---- tools ---- */
+      case "tool_use":
+        emitStandaloneToolUse(frame, out);
+        return;
+      case "tool_result":
+        emitToolResult(frame, out);
+        return;
+      /* ---- standalone reasoning / plan: passthrough as `unknown` for v1 ----
+       * These top-level (non-content_block) frames carry full content with no
+       * wire id, so they cannot be deduped across a rejoin and two bursts would
+       * collide on a synthetic id. Block-based reasoning (content_block
+       * reasoning_delta) is the dedupe-safe path and IS handled. Surface these
+       * raw until their real wire behavior is confirmed (CONTRACT.md open Q). */
+      /* ---- HITL ---- */
+      case "awaiting_approval":
+      case "permission_request":
+        emitApprovalGate(frame, out);
+        return;
+      /* ---- sandbox + notices ---- */
+      case "sandbox-connecting":
+        out.push({
+          type: "sandbox-status",
+          phase: "connecting",
+          message: str(frame, "message") ?? "Connecting to sandbox",
+          runId: num(frame, "run_id") ?? null
+        });
+        return;
+      case "sandbox-connected":
+        out.push({
+          type: "sandbox-status",
+          phase: "connected",
+          message: str(frame, "message") ?? "Connected to sandbox",
+          runId: num(frame, "run_id") ?? null,
+          ...str(frame, "sandbox_id") !== void 0 ? { sandboxId: str(frame, "sandbox_id") } : {},
+          ...num(frame, "duration_ms") !== void 0 ? { durationMs: num(frame, "duration_ms") } : {}
+        });
+        return;
+      case "stderr":
+        emitNotice(out, "info", "stderr", str(frame, "message") ?? "");
+        return;
+      case "mcp_error":
+      case "mcp_auth_failed":
+        emitNotice(out, "warning", "mcp", str(frame, "message") ?? str(frame, "error") ?? "MCP error", str(frame, "detail"));
+        return;
+      case "rate_limit": {
+        const info = obj(frame, "rate_limit_info");
+        const status = (info && str(info, "status")) ?? "allowed";
+        emitNotice(out, status === "rejected" ? "warning" : "info", "rate_limit", `Rate limit: ${status}`);
+        return;
+      }
+      case "compact_boundary":
+        out.push({
+          type: "compact-boundary",
+          trigger: str(frame, "trigger") === "manual" ? "manual" : "auto",
+          preTokens: num(frame, "pre_tokens") ?? 0
+        });
+        return;
+      /* ---- passthrough ---- */
+      default:
+        out.push({ type: "unknown", wireType: type });
+        return;
+    }
+  }
+  return {
+    push(frame) {
+      const partials = [];
+      handle(frame, partials);
+      return partials.map(
+        (e) => ({ ...e, seq: seq++, raw: frame })
+      );
+    },
+    reset
+  };
+}
+
+// src/protocol/accumulator.ts
+var initialConversationState = {
+  runId: null,
+  runUuid: null,
+  agentName: null,
+  status: "idle",
+  messages: [],
+  pendingApproval: null,
+  pendingQuestion: null,
+  finishStopReason: null,
+  error: null
+};
+function lastAssistantIndex(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") return i;
+  }
+  return -1;
+}
+function withMessageParts(state, messageId, role, fn) {
+  const messages = state.messages.slice();
+  let idx = messageId ? messages.findIndex((m) => m.id === messageId) : lastAssistantIndex(messages);
+  if (idx === -1) {
+    messages.push({ id: messageId || `m:${messages.length}`, role, parts: [] });
+    idx = messages.length - 1;
+  }
+  const msg = messages[idx];
+  messages[idx] = { ...msg, parts: fn(msg.parts) };
+  return { ...state, messages };
+}
+var isTextLike = (p) => p.kind === "text" || p.kind === "reasoning" || p.kind === "plan";
+function ensureTextPart(parts, kind, id) {
+  if (parts.some((p) => isTextLike(p) && p.id === id)) return parts;
+  return [...parts, { kind, id, text: "" }];
+}
+function applyTextDelta(parts, kind, id, delta) {
+  const i = parts.findIndex((p2) => isTextLike(p2) && p2.id === id);
+  if (i === -1) return [...parts, { kind, id, text: delta }];
+  const p = parts[i];
+  const next = parts.slice();
+  next[i] = { ...p, text: p.text + delta };
+  return next;
+}
+function updateToolPart(state, toolCallId, toolName, patch) {
+  const messages = state.messages.slice();
+  for (let mi = 0; mi < messages.length; mi++) {
+    const parts = messages[mi].parts;
+    const pi = parts.findIndex((p) => p.kind === "tool" && p.toolCallId === toolCallId);
+    if (pi !== -1) {
+      const np = parts.slice();
+      np[pi] = patch(parts[pi]);
+      messages[mi] = { ...messages[mi], parts: np };
+      return { ...state, messages };
+    }
+  }
+  let idx = lastAssistantIndex(messages);
+  if (idx === -1) {
+    messages.push({ id: `m:${messages.length}`, role: "assistant", parts: [] });
+    idx = messages.length - 1;
+  }
+  const base = {
+    kind: "tool",
+    toolCallId,
+    toolName: toolName ?? "",
+    state: "input-streaming",
+    inputText: ""
+  };
+  messages[idx] = { ...messages[idx], parts: [...messages[idx].parts, patch(base)] };
+  return { ...state, messages };
+}
+function resume(status) {
+  return status === "awaiting_approval" || status === "awaiting_input" ? "running" : status;
+}
+function accumulate(state, e) {
+  switch (e.type) {
+    case "run-start":
+      return {
+        ...state,
+        runId: e.runId,
+        runUuid: e.runUuid,
+        agentName: e.agentName ?? state.agentName ?? null,
+        status: "running",
+        error: null,
+        // A retry re-drives the turn: the previous attempt's outcome row
+        // ("Response truncated", "Request declined") must not survive it.
+        finishStopReason: null
+      };
+    case "run-status":
+      return { ...state, status: e.status };
+    case "message-start":
+      return withMessageParts(state, e.messageId, e.role, (p) => p);
+    case "text-start":
+      return {
+        ...withMessageParts(state, e.messageId, "assistant", (p) => ensureTextPart(p, "text", e.id)),
+        status: resume(state.status)
+      };
+    case "text-delta":
+      return {
+        ...withMessageParts(state, e.messageId, "assistant", (p) => applyTextDelta(p, "text", e.id, e.delta)),
+        status: resume(state.status)
+      };
+    case "reasoning-start":
+      return withMessageParts(state, e.messageId, "assistant", (p) => ensureTextPart(p, "reasoning", e.id));
+    case "reasoning-delta":
+      return withMessageParts(state, e.messageId, "assistant", (p) => applyTextDelta(p, "reasoning", e.id, e.delta));
+    case "plan-start":
+      return withMessageParts(state, e.messageId, "assistant", (p) => ensureTextPart(p, "plan", e.id));
+    case "plan-delta":
+      return withMessageParts(state, e.messageId, "assistant", (p) => applyTextDelta(p, "plan", e.id, e.delta));
+    case "text-end":
+    case "reasoning-end":
+    case "plan-end":
+    case "message-end":
+      return state;
+    case "tool-input-start":
+      return {
+        ...withMessageParts(
+          state,
+          e.messageId,
+          "assistant",
+          (p) => p.some((x) => x.kind === "tool" && x.toolCallId === e.toolCallId) ? p : [
+            ...p,
+            {
+              kind: "tool",
+              toolCallId: e.toolCallId,
+              toolName: e.toolName,
+              state: "input-streaming",
+              inputText: ""
+            }
+          ]
+        ),
+        status: resume(state.status)
+      };
+    case "tool-input-delta":
+      return updateToolPart(state, e.toolCallId, void 0, (t) => ({
+        ...t,
+        inputText: t.inputText + e.inputTextDelta,
+        state: "input-streaming"
+      }));
+    case "tool-input-available":
+      return updateToolPart(state, e.toolCallId, e.toolName, (t) => ({
+        ...t,
+        input: e.input,
+        state: "input-available"
+      }));
+    case "tool-output-available": {
+      const s = updateToolPart(state, e.toolCallId, void 0, (t) => ({
+        ...t,
+        output: e.output,
+        isError: e.isError,
+        state: e.state
+      }));
+      const pendingApproval = s.pendingApproval && s.pendingApproval.toolCallId === e.toolCallId ? null : s.pendingApproval;
+      const pendingQuestion = s.pendingQuestion && s.pendingQuestion.toolCallId === e.toolCallId ? null : s.pendingQuestion;
+      return { ...s, pendingApproval, pendingQuestion, status: resume(s.status) };
+    }
+    case "approval-request":
+      return { ...state, pendingApproval: e, status: "awaiting_approval" };
+    case "approval-resolved":
+      return state.pendingApproval && state.pendingApproval.requestId === e.requestId ? { ...state, pendingApproval: null } : state;
+    case "question":
+      return { ...state, pendingQuestion: e, status: "awaiting_input" };
+    case "run-finish":
+      return { ...state, status: e.status, pendingApproval: null, pendingQuestion: null };
+    case "run-error":
+      return {
+        ...state,
+        status: "error",
+        error: {
+          message: e.message,
+          code: e.code,
+          ...e.apiStatus !== void 0 ? { apiStatus: e.apiStatus } : {},
+          ...e.apiDetails !== void 0 ? { apiDetails: e.apiDetails } : {}
+        },
+        pendingApproval: null,
+        pendingQuestion: null
+      };
+    case "run-cancelled":
+      return { ...state, status: "cancelled", pendingApproval: null, pendingQuestion: null };
+    case "sandbox-status": {
+      const withStatus = e.phase === "connecting" && state.status === "idle" ? { ...state, status: "connecting" } : state;
+      if (e.phase === "connecting") {
+        return withMessageParts(withStatus, "", "assistant", (p) => [
+          ...p,
+          { kind: "sandbox", id: `sb:${p.length}`, phase: "connecting" }
+        ]);
+      }
+      const messages = withStatus.messages.slice();
+      for (let mi = messages.length - 1; mi >= 0; mi--) {
+        const parts = messages[mi].parts;
+        for (let pi = parts.length - 1; pi >= 0; pi--) {
+          const part = parts[pi];
+          if (part.kind === "sandbox" && part.phase === "connecting") {
+            const np = parts.slice();
+            np[pi] = { ...part, phase: "connected", ...e.durationMs !== void 0 ? { durationMs: e.durationMs } : {} };
+            messages[mi] = { ...messages[mi], parts: np };
+            return { ...withStatus, messages };
+          }
+        }
+      }
+      return withMessageParts(withStatus, "", "assistant", (p) => [
+        ...p,
+        { kind: "sandbox", id: `sb:${p.length}`, phase: "connected", ...e.durationMs !== void 0 ? { durationMs: e.durationMs } : {} }
+      ]);
+    }
+    case "notice":
+      if (e.level !== "warning") return state;
+      return withMessageParts(state, "", "assistant", (p) => [
+        ...p,
+        { kind: "notice", id: `n:${p.length}`, level: e.level, source: e.source, message: e.message }
+      ]);
+    case "compact-boundary":
+      return withMessageParts(state, "", "assistant", (p) => [
+        ...p,
+        { kind: "compact", id: `c:${p.length}`, trigger: e.trigger, preTokens: e.preTokens }
+      ]);
+    case "run-metrics":
+      return e.stopReason === "refusal" || e.stopReason === "max_tokens" ? { ...state, finishStopReason: e.stopReason } : state;
+    case "unknown":
+      return state;
+    default:
+      return state;
+  }
+}
+function createAccumulator() {
+  let state = initialConversationState;
+  return {
+    get state() {
+      return state;
+    },
+    apply(event) {
+      state = accumulate(state, event);
+      return state;
+    },
+    addUserMessage(text) {
+      const id = `u:${state.messages.length}`;
+      state = {
+        ...state,
+        messages: [...state.messages, { id, role: "user", parts: [{ kind: "text", id, text }] }]
+      };
+      return state;
+    },
+    reset() {
+      state = initialConversationState;
+    }
+  };
+}
+
+// src/protocol/errors.ts
+var M8tesApiError = class extends Error {
+  type;
+  code;
+  status;
+  requestId;
+  details;
+  docUrl;
+  errorCode;
+  retryAfter;
+  constructor(message, f) {
+    super(message);
+    this.name = "M8tesApiError";
+    this.type = f.type;
+    this.code = f.code;
+    this.status = f.status;
+    this.requestId = f.requestId;
+    this.details = f.details;
+    this.docUrl = f.docUrl;
+    this.errorCode = f.errorCode;
+    this.retryAfter = f.retryAfter;
+  }
+};
+var ValidationError = class extends M8tesApiError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "ValidationError";
+  }
+};
+var AuthenticationError = class extends M8tesApiError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "AuthenticationError";
+  }
+};
+var BillingError = class extends M8tesApiError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "BillingError";
+  }
+};
+var PermissionDeniedError = class extends M8tesApiError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "PermissionDeniedError";
+  }
+};
+var NotFoundError = class extends M8tesApiError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends M8tesApiError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "ConflictError";
+  }
+};
+var RunNotStreamingError = class extends ConflictError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "RunNotStreamingError";
+  }
+};
+var RateLimitError = class extends M8tesApiError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "RateLimitError";
+  }
+};
+var APIError = class extends M8tesApiError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "APIError";
+  }
+};
+var RunFailedError = class extends M8tesApiError {
+  constructor(message, f) {
+    super(message, f);
+    this.name = "RunFailedError";
+  }
+};
+var STATUS_MAP = {
+  400: ValidationError,
+  401: AuthenticationError,
+  402: BillingError,
+  403: PermissionDeniedError,
+  404: NotFoundError,
+  409: ConflictError,
+  422: ValidationError,
+  429: RateLimitError
+};
+function parseRetryAfter(raw) {
+  if (!raw) return void 0;
+  const seconds = Number(raw);
+  return Number.isFinite(seconds) ? seconds : void 0;
+}
+function str2(o, key) {
+  return typeof o[key] === "string" ? o[key] : void 0;
+}
+function parseErrorEnvelope(status, body, headers) {
+  const e = body !== null && typeof body === "object" && "error" in body && typeof body.error === "object" ? body.error ?? {} : {};
+  const details = e["details"];
+  const errorCode = details !== null && typeof details === "object" ? str2(details, "error_code") : void 0;
+  return {
+    message: str2(e, "message") ?? `Request failed (${status})`,
+    fields: {
+      type: str2(e, "type") ?? "api_error",
+      code: typeof e["code"] === "number" ? e["code"] : status,
+      status,
+      requestId: str2(e, "request_id") ?? headers?.get("x-request-id") ?? void 0,
+      details,
+      docUrl: str2(e, "doc_url"),
+      errorCode,
+      retryAfter: parseRetryAfter(headers?.get("retry-after"))
+    }
+  };
+}
+function errorClassForStatus(status, opts = {}) {
+  if (status === 409 && opts.conflictIsNotStreaming) return RunNotStreamingError;
+  return STATUS_MAP[status] ?? APIError;
+}
+async function errorFromResponse(res, opts = {}) {
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = void 0;
+  }
+  const { message, fields } = parseErrorEnvelope(res.status, body, res.headers);
+  const Cls = errorClassForStatus(res.status, opts);
+  return new Cls(message, fields);
+}
+
+export { APIError, AuthenticationError, BillingError, ConflictError, M8tesApiError, NotFoundError, PROTOCOL_VERSION, PermissionDeniedError, RateLimitError, RunFailedError, RunNotStreamingError, TERMINAL_EVENT_TYPES, ValidationError, accumulate, createAccumulator, createNormalizer, createSseDecoder, errorClassForStatus, errorFromResponse, initialConversationState, isTerminalEvent, parseErrorEnvelope, parseRetryAfter, parseSse, splitConcatenatedJson };
+//# sourceMappingURL=chunk-UFQQNUFE.js.map
+//# sourceMappingURL=chunk-UFQQNUFE.js.map