@m8tes/sdk 0.1.0-alpha.1

package/dist/index.cjs

@@ -0,0 +1,1783 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// 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);
+}
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://api.m8tes.ai/api/v2";
+var MAX_ATTEMPTS = 3;
+var INITIAL_BACKOFF_MS = 500;
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+function backoff(ms, signal) {
+  if (signal?.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+function looksLikeHtml(res, text) {
+  if ((res.headers.get("content-type") ?? "").includes("text/html")) return true;
+  const head = text.trimStart().slice(0, 9).toLowerCase();
+  return head.startsWith("<!doctype") || head.startsWith("<html");
+}
+function diagnose(res, text, body, url) {
+  if (looksLikeHtml(res, text)) {
+    return `Received an HTML page instead of an API response (HTTP ${res.status}) from ${url}. This usually means the host does not serve the m8tes API; check your baseUrl (the hosted API is ${DEFAULT_BASE_URL}).`;
+  }
+  const isBareNotFound = res.status === 404 && body !== null && typeof body === "object" && !("error" in body) && body.detail === "Not Found";
+  if (isBareNotFound) {
+    return `HTTP 404 from ${url} with no API error envelope \u2014 the path matched no route. Check your baseUrl includes the /api/v2 prefix (the hosted API is ${DEFAULT_BASE_URL}).`;
+  }
+  return void 0;
+}
+function createHttp(options = {}) {
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    throw new Error(
+      "@m8tes/sdk is server-only: it holds your secret m8_ API key, which anyone could read out of a browser bundle. To render an agent in the browser use @m8tes/react, which talks to a server proxy that keeps the key on your server. See https://www.m8tes.ai/docs/embed-a-ui"
+    );
+  }
+  const apiKey = options.apiKey ?? globalThis.process?.env?.["M8TES_API_KEY"];
+  if (!apiKey) {
+    throw new Error(
+      "@m8tes/sdk: no API key. Pass `new M8tes({ apiKey })` or set M8TES_API_KEY. Create a key at https://m8tes.ai/developer."
+    );
+  }
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const timeout = options.timeout ?? 3e5;
+  const maybeFetch = options.fetch ?? globalThis.fetch;
+  if (!maybeFetch) {
+    throw new Error(
+      "@m8tes/sdk: no global fetch. Use Node 18+ or pass `fetch` in the client options."
+    );
+  }
+  const fetchImpl = maybeFetch;
+  async function toError(res, url, errOpts) {
+    const text = await res.text().catch(() => "");
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = void 0;
+    }
+    const parsed = parseErrorEnvelope(res.status, body, res.headers);
+    const message = diagnose(res, text, body, url) ?? (body ? parsed.message : text || parsed.message);
+    return new (errorClassForStatus(res.status, errOpts))(message, parsed.fields);
+  }
+  async function attempt(method, url, opts) {
+    const headers = {
+      authorization: `Bearer ${apiKey}`,
+      ...options.headers,
+      ...opts.headers
+    };
+    const init = { method, headers };
+    if (opts.body !== void 0) {
+      headers["content-type"] = "application/json";
+      init.body = JSON.stringify(opts.body);
+    }
+    const timer = AbortSignal.timeout(timeout);
+    init.signal = opts.signal ? AbortSignal.any([opts.signal, timer]) : timer;
+    return fetchImpl(url, init);
+  }
+  async function send(method, path, opts, errOpts = {}) {
+    const url = `${baseUrl}${path}${opts.query ?? ""}`;
+    const idempotent = IDEMPOTENT_METHODS.has(method.toUpperCase());
+    let lastNetworkError;
+    for (let i = 0; i < MAX_ATTEMPTS; i++) {
+      const isLast = i === MAX_ATTEMPTS - 1;
+      let res;
+      try {
+        res = await attempt(method, url, opts);
+      } catch (e) {
+        if (opts.signal?.aborted) throw e;
+        lastNetworkError = e;
+        if (!idempotent || isLast) {
+          throw new APIError(e instanceof Error ? e.message : String(e), {
+            type: "api_error",
+            code: 0,
+            status: 0
+          });
+        }
+        await backoff(INITIAL_BACKOFF_MS * 2 ** i, opts.signal);
+        if (opts.signal?.aborted) throw e;
+        continue;
+      }
+      if (res.ok) return res;
+      if (!RETRYABLE_STATUS.has(res.status) || !idempotent || isLast) {
+        throw await toError(res, url, errOpts);
+      }
+      const retryAfter = res.status === 429 ? parseRetryAfter(res.headers.get("retry-after")) : void 0;
+      await res.text().catch(() => "");
+      await backoff(retryAfter !== void 0 ? retryAfter * 1e3 : INITIAL_BACKOFF_MS * 2 ** i, opts.signal);
+      if (opts.signal?.aborted) throw await toError(res, url, errOpts);
+    }
+    throw new APIError(
+      lastNetworkError instanceof Error ? lastNetworkError.message : "Max retries exceeded",
+      { type: "api_error", code: 0, status: 0 }
+    );
+  }
+  return {
+    baseUrl,
+    async request(method, path, opts = {}) {
+      const res = await send(method, path, opts);
+      if (res.status === 204) return void 0;
+      const text = await res.text();
+      return text ? JSON.parse(text) : void 0;
+    },
+    raw(method, path, opts = {}) {
+      return send(method, path, opts);
+    },
+    async *stream(method, path, opts = {}) {
+      const res = await send(method, path, opts, { conflictIsNotStreaming: true });
+      if (!res.body) return;
+      const normalizer = opts.normalizer ?? createNormalizer();
+      const decoder = createSseDecoder({ onMalformed: options.onMalformed });
+      const reader = res.body.getReader();
+      const td = new TextDecoder();
+      try {
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          for (const frame of decoder.push(td.decode(value, { stream: true }))) {
+            yield* normalizer.push(frame);
+          }
+        }
+        for (const frame of decoder.flush()) yield* normalizer.push(frame);
+      } finally {
+        try {
+          await reader.cancel();
+        } catch {
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/pagination.ts
+var Page = class {
+  data;
+  hasMore;
+  /** Fetches the next page given a cursor. Absent on a terminal page. */
+  fetchNext;
+  constructor(data, hasMore, fetchNext) {
+    this.data = data;
+    this.hasMore = hasMore;
+    this.fetchNext = fetchNext;
+  }
+  /**
+   * Auto-paging: yields every item across every page.
+   *
+   * Stops if the cursor ever fails to advance. A server that returns the same
+   * page again with `has_more: true` — a caching layer, a replica lagging, a bug
+   * — would otherwise spin forever, re-yielding the same rows and never
+   * returning. Terminating is the only safe response: the caller gets the items
+   * it did see rather than a hung process.
+   */
+  async *[Symbol.asyncIterator]() {
+    let page = this;
+    const seen = /* @__PURE__ */ new Set();
+    for (; ; ) {
+      yield* page.data;
+      const last = page.data.at(-1);
+      if (!page.hasMore || !last || !page.fetchNext) return;
+      const cursor = typeof last.id === "number" || typeof last.id === "string" ? last.id : typeof last.name === "string" ? last.name : void 0;
+      if (cursor === void 0 || seen.has(cursor)) return;
+      seen.add(cursor);
+      page = await page.fetchNext(cursor);
+    }
+  }
+  /** Every item across every page, collected. Prefer iteration for large sets. */
+  async all() {
+    const out = [];
+    for await (const item of this) out.push(item);
+    return out;
+  }
+};
+
+// src/params.ts
+function toBody(params) {
+  const out = {};
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+function toQuery(params) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === null) continue;
+    q.set(k, String(v));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+function resolveAgentId(teammateId, agentId) {
+  if (agentId !== void 0 && teammateId !== void 0 && agentId !== teammateId) {
+    throw new Error("Pass agent_id or teammate_id, not both");
+  }
+  return teammateId ?? agentId;
+}
+
+// src/resources/agents.ts
+function createAgentsResource(http) {
+  return {
+    create(params = {}) {
+      return http.request("POST", "/agents/", { body: toBody({ ...params }) });
+    },
+    async list(params = {}) {
+      const fetchPage = async (p) => {
+        const res = await http.request("GET", "/agents/", {
+          query: toQuery(p)
+        });
+        return new Page(
+          res?.data ?? [],
+          res?.has_more ?? false,
+          (starting_after) => fetchPage({ ...p, starting_after })
+        );
+      };
+      return fetchPage({ ...params });
+    },
+    get(agentId, params = {}) {
+      return http.request("GET", `/agents/${agentId}`, { query: toQuery(params) });
+    },
+    update(agentId, params) {
+      const { user_id, ...patch } = params;
+      return http.request("PATCH", `/agents/${agentId}`, {
+        body: toBody(patch),
+        query: toQuery({ user_id })
+      });
+    },
+    async delete(agentId, params = {}) {
+      await http.request("DELETE", `/agents/${agentId}`, { query: toQuery(params) });
+    },
+    enableWebhook(agentId) {
+      return http.request("POST", `/agents/${agentId}/webhook`, { body: {} });
+    },
+    async disableWebhook(agentId) {
+      await http.request("DELETE", `/agents/${agentId}/webhook`);
+    },
+    enableEmailInbox(agentId) {
+      return http.request("POST", `/agents/${agentId}/email-inbox`, { body: {} });
+    },
+    async disableEmailInbox(agentId) {
+      await http.request("DELETE", `/agents/${agentId}/email-inbox`);
+    }
+  };
+}
+
+// src/resources/apps.ts
+function createAppsResource(http) {
+  const slug = (name) => encodeURIComponent(name);
+  return {
+    async list(params = {}) {
+      const res = await http.request("GET", "/apps/", {
+        query: toQuery({ user_id: params.user_id })
+      });
+      return new Page(res?.data ?? [], res?.has_more ?? false);
+    },
+    async isConnected(appName, params = {}) {
+      const { data } = await this.list(params);
+      return data.find((a) => a.name === appName)?.connected ?? false;
+    },
+    connectOauth(appName, params) {
+      return http.request("POST", `/apps/${slug(appName)}/connect`, {
+        body: toBody({ ...params })
+      });
+    },
+    connectApiKey(appName, params) {
+      return http.request("POST", `/apps/${slug(appName)}/connect/api-key`, {
+        body: toBody({ ...params })
+      });
+    },
+    connectComplete(appName, params) {
+      return http.request("POST", `/apps/${slug(appName)}/connect/complete`, {
+        body: toBody({ ...params })
+      });
+    },
+    async disconnect(appName, params = {}) {
+      await http.request("DELETE", `/apps/${slug(appName)}/connections`, { query: toQuery(params) });
+    }
+  };
+}
+
+// src/streaming.ts
+var RunStream = class {
+  source;
+  raiseOnError;
+  state = initialConversationState;
+  textChunks = [];
+  errorMessages = [];
+  runIdValue = null;
+  consumed = false;
+  constructor(source, options = {}) {
+    this.source = source;
+    this.raiseOnError = options.raiseOnError ?? false;
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this.consumed) {
+      throw new Error(
+        "RunStream has already been consumed. A stream is single-pass \u2014 iterate once, then read .text / .state / .errors, or call runs.get(runId) to re-read the result."
+      );
+    }
+    this.consumed = true;
+    try {
+      for await (const event of this.source) {
+        this.state = accumulate(this.state, event);
+        if (event.type === "text-delta") this.textChunks.push(event.delta);
+        if (event.type === "run-start" && event.runId !== null) this.runIdValue = event.runId;
+        if (event.type === "run-error") this.errorMessages.push(event.message || event.error);
+        yield event;
+      }
+    } finally {
+      await this.source.return(void 0).catch(() => void 0);
+    }
+    if (this.raiseOnError && this.errorMessages.length > 0) {
+      throw new RunFailedError(`Run failed: ${this.errorMessages.join("; ")}`, {
+        type: "run_failed",
+        code: 0,
+        status: 0,
+        details: { errors: this.errorMessages }
+      });
+    }
+  }
+  /** Yield only the assistant's text, in order. The 90% case for a server. */
+  async *iterText() {
+    for await (const event of this) {
+      if (event.type === "text-delta") yield event.delta;
+    }
+  }
+  /** Drain the stream and return the full assistant text. */
+  async text() {
+    for await (const _ of this) {
+    }
+    return this.textChunks.join("");
+  }
+  /** Accumulated text so far (complete once iteration finishes). */
+  get output() {
+    return this.textChunks.join("");
+  }
+  /** Run id, available as soon as the first `run-start` event arrives. */
+  get runId() {
+    return this.runIdValue;
+  }
+  /** Error messages the run emitted. Check this, or pass `raiseOnError`. */
+  get errors() {
+    return [...this.errorMessages];
+  }
+  get hasErrors() {
+    return this.errorMessages.length > 0;
+  }
+  /** Full normalized conversation: messages, tool calls, notices, status. */
+  get conversation() {
+    return this.state;
+  }
+  /** Close the underlying response without draining it. */
+  async close() {
+    await this.source.return(void 0).catch(() => void 0);
+  }
+};
+
+// src/resources/runs.ts
+function items(payload) {
+  return Array.isArray(payload) ? payload : payload?.data ?? [];
+}
+function createRunsResource(http) {
+  const createBody = (p, stream) => {
+    const { agent_id, teammate_id, ...rest } = p;
+    return toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id), stream });
+  };
+  return {
+    create(params, options) {
+      return new RunStream(http.stream("POST", "/runs", { body: createBody(params, true) }), options);
+    },
+    createAsync(params) {
+      return http.request("POST", "/runs", { body: createBody(params, false) });
+    },
+    stream(runId, options) {
+      return new RunStream(http.stream("GET", `/runs/${runId}/stream`), options);
+    },
+    reply(runId, message, options) {
+      return new RunStream(http.stream("POST", `/runs/${runId}/reply`, { body: { message } }), options);
+    },
+    get(runId) {
+      return http.request("GET", `/runs/${runId}`);
+    },
+    async list(params = {}) {
+      const { agent_id, teammate_id, ...rest } = params;
+      const q = toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id) });
+      const fetchPage = async (p) => {
+        const res = await http.request("GET", "/runs", {
+          query: toQuery(p)
+        });
+        return new Page(
+          res?.data ?? [],
+          res?.has_more ?? false,
+          (starting_after) => fetchPage({ ...p, starting_after })
+        );
+      };
+      return fetchPage(q);
+    },
+    cancel(runId) {
+      return http.request("POST", `/runs/${runId}/cancel`, { body: {} });
+    },
+    approve(runId, params) {
+      return http.request("POST", `/runs/${runId}/approve`, {
+        body: { remember: false, ...params }
+      });
+    },
+    answer(runId, params) {
+      return http.request("POST", `/runs/${runId}/answer`, {
+        body: { answers: params.answers }
+      });
+    },
+    async permissions(runId) {
+      return items(await http.request("GET", `/runs/${runId}/permissions`));
+    },
+    outcome(runId) {
+      return http.request("GET", `/runs/${runId}/outcome`);
+    },
+    async files(runId) {
+      return items(await http.request("GET", `/runs/${runId}/files`));
+    },
+    async downloadFile(runId, filename) {
+      const res = await http.raw("GET", `/runs/${runId}/files/${encodeURIComponent(filename)}/download`, {
+        headers: { accept: "application/octet-stream" }
+      });
+      return res.arrayBuffer();
+    }
+  };
+}
+
+// src/resources/settings.ts
+function createSettingsResource(http) {
+  return {
+    get() {
+      return http.request("GET", "/settings/");
+    },
+    // `null` must survive (it CLEARS a cap); only `undefined` is dropped.
+    update(params) {
+      return http.request("PATCH", "/settings/", { body: toBody({ ...params }) });
+    }
+  };
+}
+
+// src/resources/tasks.ts
+function createTasksResource(http) {
+  const triggers = {
+    create(taskId, params) {
+      return http.request("POST", `/tasks/${taskId}/triggers/`, {
+        body: toBody({ timezone: "UTC", ...params })
+      });
+    },
+    async list(taskId) {
+      const res = await http.request(
+        "GET",
+        `/tasks/${taskId}/triggers/`
+      );
+      return Array.isArray(res) ? res : res?.data ?? [];
+    },
+    update(taskId, triggerId, params) {
+      return http.request("PATCH", `/tasks/${taskId}/triggers/${triggerId}`, {
+        body: toBody({ ...params })
+      });
+    },
+    async delete(taskId, triggerId) {
+      await http.request("DELETE", `/tasks/${taskId}/triggers/${triggerId}`);
+    }
+  };
+  return {
+    triggers,
+    create(params) {
+      const { agent_id, teammate_id, ...rest } = params;
+      return http.request("POST", "/tasks/", {
+        body: toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id) })
+      });
+    },
+    async list(params = {}) {
+      const { agent_id, teammate_id, ...rest } = params;
+      const q = toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id) });
+      const fetchPage = async (p) => {
+        const res = await http.request("GET", "/tasks/", {
+          query: toQuery(p)
+        });
+        return new Page(
+          res?.data ?? [],
+          res?.has_more ?? false,
+          (starting_after) => fetchPage({ ...p, starting_after })
+        );
+      };
+      return fetchPage(q);
+    },
+    get(taskId, params = {}) {
+      return http.request("GET", `/tasks/${taskId}`, { query: toQuery(params) });
+    },
+    update(taskId, params) {
+      const { user_id, ...patch } = params;
+      return http.request("PATCH", `/tasks/${taskId}`, {
+        body: toBody(patch),
+        query: toQuery({ user_id })
+      });
+    },
+    async delete(taskId, params = {}) {
+      await http.request("DELETE", `/tasks/${taskId}`, { query: toQuery(params) });
+    },
+    run(taskId, params = {}, options) {
+      return new RunStream(
+        http.stream("POST", `/tasks/${taskId}/runs`, { body: toBody({ ...params, stream: true }) }),
+        options
+      );
+    },
+    runAsync(taskId, params = {}) {
+      return http.request("POST", `/tasks/${taskId}/runs`, {
+        body: toBody({ ...params, stream: false })
+      });
+    },
+    enableWebhook(taskId) {
+      return http.request("POST", `/tasks/${taskId}/webhook`, { body: {} });
+    },
+    async disableWebhook(taskId) {
+      await http.request("DELETE", `/tasks/${taskId}/webhook`);
+    }
+  };
+}
+
+// src/resources/users.ts
+function pager(http, path) {
+  const fetchPage = async (p) => {
+    const res = await http.request("GET", path, {
+      query: toQuery(p)
+    });
+    return new Page(
+      res?.data ?? [],
+      res?.has_more ?? false,
+      (starting_after) => fetchPage({ ...p, starting_after })
+    );
+  };
+  return fetchPage;
+}
+function createUsersResource(http) {
+  return {
+    create(params) {
+      return http.request("POST", "/users/", { body: toBody({ ...params }) });
+    },
+    list(params = {}) {
+      return pager(http, "/users/")({ ...params });
+    },
+    get(userId) {
+      return http.request("GET", `/users/${encodeURIComponent(userId)}`);
+    },
+    update(userId, params) {
+      return http.request("PATCH", `/users/${encodeURIComponent(userId)}`, {
+        body: toBody({ ...params })
+      });
+    },
+    async delete(userId) {
+      await http.request("DELETE", `/users/${encodeURIComponent(userId)}`);
+    },
+    usage(params = {}) {
+      return pager(http, "/usage/end-users")({ ...params });
+    }
+  };
+}
+function verifySignature(body, headers, secret, options = {}) {
+  const get = (name) => {
+    if (typeof headers.get === "function") {
+      return headers.get(name) ?? void 0;
+    }
+    const lower = Object.fromEntries(
+      Object.entries(headers).map(([k, v]) => [
+        k.toLowerCase(),
+        Array.isArray(v) ? v[0] : v
+      ])
+    );
+    return lower[name];
+  };
+  const webhookId = get("webhook-id");
+  const timestamp = get("webhook-timestamp");
+  const signature = get("webhook-signature");
+  if (!webhookId || !timestamp || !signature) return false;
+  if (options.toleranceSeconds !== void 0) {
+    const ts = Number.parseInt(timestamp, 10);
+    if (!Number.isFinite(ts)) return false;
+    const now = options.now ? options.now() : Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - ts) > options.toleranceSeconds) return false;
+  }
+  const raw = typeof body === "string" ? body : new TextDecoder().decode(body);
+  const expected = `v1=${crypto.createHmac("sha256", secret).update(`${webhookId}.${timestamp}.${raw}`).digest("hex")}`;
+  const a = Buffer.from(expected);
+  const b = Buffer.from(signature);
+  return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+function createWebhooksResource(http) {
+  return {
+    verifySignature,
+    create(params) {
+      return http.request("POST", "/webhooks/", { body: toBody({ ...params }) });
+    },
+    list(params = {}) {
+      return pager(http, "/webhooks/")({ ...params });
+    },
+    get(webhookId) {
+      return http.request("GET", `/webhooks/${webhookId}`);
+    },
+    update(webhookId, params) {
+      return http.request("PATCH", `/webhooks/${webhookId}`, { body: toBody({ ...params }) });
+    },
+    async delete(webhookId) {
+      await http.request("DELETE", `/webhooks/${webhookId}`);
+    },
+    listDeliveries(webhookId, params = {}) {
+      return pager(http, `/webhooks/${webhookId}/deliveries`)({ ...params });
+    }
+  };
+}
+
+// src/index.ts
+var M8TES_SDK_VERSION = "0.1.0-alpha.1";
+var M8tes = class {
+  runs;
+  agents;
+  /** Permanent alias for `agents` — the DB model and older docs say "teammate". */
+  teammates;
+  tasks;
+  users;
+  apps;
+  webhooks;
+  settings;
+  /** The underlying transport. Use it to call an endpoint this version does not wrap yet. */
+  http;
+  constructor(options = {}) {
+    this.http = createHttp(options);
+    this.runs = createRunsResource(this.http);
+    this.agents = createAgentsResource(this.http);
+    this.teammates = this.agents;
+    this.tasks = createTasksResource(this.http);
+    this.users = createUsersResource(this.http);
+    this.apps = createAppsResource(this.http);
+    this.webhooks = createWebhooksResource(this.http);
+    this.settings = createSettingsResource(this.http);
+  }
+};
+
+exports.APIError = APIError;
+exports.AuthenticationError = AuthenticationError;
+exports.BillingError = BillingError;
+exports.ConflictError = ConflictError;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.M8TES_SDK_VERSION = M8TES_SDK_VERSION;
+exports.M8tes = M8tes;
+exports.M8tesApiError = M8tesApiError;
+exports.NotFoundError = NotFoundError;
+exports.PROTOCOL_VERSION = PROTOCOL_VERSION;
+exports.Page = Page;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.RateLimitError = RateLimitError;
+exports.RunFailedError = RunFailedError;
+exports.RunNotStreamingError = RunNotStreamingError;
+exports.RunStream = RunStream;
+exports.TERMINAL_EVENT_TYPES = TERMINAL_EVENT_TYPES;
+exports.ValidationError = ValidationError;
+exports.accumulate = accumulate;
+exports.createAccumulator = createAccumulator;
+exports.createHttp = createHttp;
+exports.createNormalizer = createNormalizer;
+exports.createSseDecoder = createSseDecoder;
+exports.errorClassForStatus = errorClassForStatus;
+exports.errorFromResponse = errorFromResponse;
+exports.initialConversationState = initialConversationState;
+exports.isTerminalEvent = isTerminalEvent;
+exports.parseErrorEnvelope = parseErrorEnvelope;
+exports.parseRetryAfter = parseRetryAfter;
+exports.parseSse = parseSse;
+exports.splitConcatenatedJson = splitConcatenatedJson;
+exports.verifySignature = verifySignature;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map