@frumu/tandem-client 0.3.22

package/dist/index.js

@@ -0,0 +1,1239 @@
+// src/normalize/index.ts
+import { z } from "zod";
+var TandemValidationError = class extends Error {
+  constructor(endpoint, status, issues, rawSnippet) {
+    super(`Tandem API Validation Error [${status}] at ${endpoint}: ${issues.length} issues found.`);
+    this.endpoint = endpoint;
+    this.status = status;
+    this.issues = issues;
+    this.rawSnippet = rawSnippet;
+    this.name = "TandemValidationError";
+  }
+};
+var idNormalizer = z.string().or(z.object({
+  id: z.string().optional(),
+  runID: z.string().optional(),
+  runId: z.string().optional(),
+  run_id: z.string().optional(),
+  sessionID: z.string().optional(),
+  sessionId: z.string().optional(),
+  session_id: z.string().optional(),
+  missionID: z.string().optional(),
+  missionId: z.string().optional(),
+  mission_id: z.string().optional(),
+  instanceID: z.string().optional(),
+  instanceId: z.string().optional(),
+  instance_id: z.string().optional()
+})).transform((val) => {
+  if (typeof val === "string") return val;
+  return val.id || val.runID || val.runId || val.run_id || val.sessionID || val.sessionId || val.session_id || val.missionID || val.missionId || val.mission_id || val.instanceID || val.instanceId || val.instance_id;
+});
+var jsonFallback = z.any().transform((val) => val);
+var jsonObjectFallback = z.record(z.string(), z.any()).transform((val) => val);
+var SystemHealthSchema = z.object({
+  ready: z.boolean().optional(),
+  phase: z.string().optional()
+}).passthrough();
+var SessionRecordSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  created_at_ms: z.number().optional(),
+  createdAtMs: z.number().optional(),
+  directory: z.string().optional(),
+  workspace_root: z.string().optional(),
+  workspaceRoot: z.string().optional(),
+  archived: z.boolean().optional()
+}).passthrough().transform((val) => ({
+  ...val,
+  createdAtMs: val.created_at_ms ?? val.createdAtMs ?? 0,
+  workspaceRoot: val.workspace_root ?? val.workspaceRoot
+}));
+var SessionListResponseSchema = z.object({
+  sessions: z.array(SessionRecordSchema).optional().default([]),
+  count: z.number().optional().default(0)
+}).passthrough();
+var SessionRunStateResponseSchema = z.object({
+  active: z.object({
+    runID: z.string().optional(),
+    runId: z.string().optional(),
+    run_id: z.string().optional(),
+    attachEventStream: z.string().optional()
+  }).passthrough().nullable().optional()
+}).passthrough().transform((val) => {
+  if (!val.active) return { active: null };
+  return {
+    active: {
+      ...val.active,
+      runId: val.active.runId || val.active.runID || val.active.run_id
+    }
+  };
+});
+var RunNowResponseSchema = z.object({
+  ok: z.boolean().optional(),
+  runID: z.string().optional(),
+  runId: z.string().optional(),
+  run_id: z.string().optional(),
+  status: z.string().optional()
+}).passthrough().transform((val) => ({
+  ...val,
+  runId: val.runId || val.runID || val.run_id
+}));
+var RunRecordSchema = z.object({
+  id: z.string().optional(),
+  runID: z.string().optional(),
+  runId: z.string().optional(),
+  run_id: z.string().optional(),
+  routine_id: z.string().optional(),
+  automation_id: z.string().optional(),
+  status: z.string().optional(),
+  started_at_ms: z.number().optional(),
+  finished_at_ms: z.number().optional()
+}).passthrough().transform((val) => ({
+  ...val,
+  runId: val.runId || val.runID || val.run_id,
+  routineId: val.routine_id,
+  automationId: val.automation_id,
+  startedAtMs: val.started_at_ms,
+  finishedAtMs: val.finished_at_ms
+}));
+var ResourceWriteResponseSchema = z.object({
+  ok: z.boolean().default(true),
+  rev: z.number().optional()
+}).passthrough();
+var ResourceRecordSchema = z.object({
+  key: z.string(),
+  value: z.any(),
+  rev: z.number().optional(),
+  updated_at_ms: z.number().optional(),
+  updated_by: z.string().optional()
+}).passthrough().transform((val) => ({
+  ...val,
+  updatedAtMs: val.updated_at_ms,
+  updatedBy: val.updated_by
+}));
+var ResourceListResponseSchema = z.object({
+  items: z.array(ResourceRecordSchema).optional().default([]),
+  count: z.number().optional().default(0)
+}).passthrough();
+var MemoryItemSchema = z.object({
+  id: z.string().optional(),
+  text: z.string(),
+  tags: z.array(z.string()).optional(),
+  source: z.string().optional(),
+  session_id: z.string().optional(),
+  sessionID: z.string().optional(),
+  run_id: z.string().optional(),
+  runID: z.string().optional()
+}).passthrough().transform((val) => ({
+  ...val,
+  sessionId: val.session_id || val.sessionID,
+  runId: val.run_id || val.runID
+}));
+var MemoryListResponseSchema = z.object({
+  items: z.array(MemoryItemSchema).optional().default([]),
+  count: z.number().optional().default(0)
+}).passthrough();
+var MemorySearchResultSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  score: z.number().optional(),
+  tags: z.array(z.string()).optional()
+}).passthrough();
+var MemorySearchResponseSchema = z.object({
+  results: z.array(MemorySearchResultSchema).optional().default([]),
+  count: z.number().optional().default(0)
+}).passthrough();
+var EngineEventSchema = z.object({
+  type: z.string(),
+  properties: z.record(z.string(), z.any()).optional().default({}),
+  sessionID: z.string().optional(),
+  session_id: z.string().optional(),
+  sessionId: z.string().optional(),
+  runID: z.string().optional(),
+  run_id: z.string().optional(),
+  runId: z.string().optional(),
+  timestamp: z.string().optional()
+}).passthrough().transform((val) => {
+  return {
+    ...val,
+    properties: val.properties,
+    sessionId: val.sessionId || val.sessionID || val.session_id,
+    runId: val.runId || val.runID || val.run_id
+  };
+});
+function parseResponse(schema, rawData, endpoint, status) {
+  const result = schema.safeParse(rawData);
+  if (!result.success) {
+    const snippet = JSON.stringify(rawData).substring(0, 200);
+    throw new TandemValidationError(endpoint, status, result.error.issues, snippet);
+  }
+  return result.data;
+}
+
+// src/stream.ts
+function parseSseLine(data) {
+  const trimmed = data.trim();
+  if (!trimmed || trimmed === ": keep-alive" || trimmed.startsWith(":")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    const result = EngineEventSchema.safeParse(parsed);
+    if (result.success) return result.data;
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function* filterByType(stream, type) {
+  for await (const event of stream) {
+    if (event.type === type) {
+      yield event;
+    }
+  }
+}
+async function on(stream, type, callback) {
+  for await (const event of stream) {
+    if (event.type === type) {
+      await callback(event);
+    }
+  }
+}
+async function* streamSse(url, token, options) {
+  const connectTimeoutMs = options?.connectTimeoutMs ?? 3e4;
+  const controller = new AbortController();
+  const connectTimer = setTimeout(() => controller.abort(), connectTimeoutMs);
+  const combinedSignal = options?.signal ? anySignal([controller.signal, options.signal]) : controller.signal;
+  let res;
+  try {
+    res = await fetch(url, {
+      headers: {
+        Accept: "text/event-stream",
+        Authorization: `Bearer ${token}`,
+        "Cache-Control": "no-cache"
+      },
+      signal: combinedSignal
+    });
+  } finally {
+    clearTimeout(connectTimer);
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`SSE connect failed (${res.status} ${res.statusText}): ${body}`);
+  }
+  if (!res.body) throw new Error("SSE response has no body");
+  const decoder = new TextDecoder();
+  const reader = res.body.getReader();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      let currentData = "";
+      for (const line of lines) {
+        if (line.startsWith("data:")) {
+          currentData += line.slice(5).trimStart();
+        } else if (line === "") {
+          if (currentData) {
+            const event = parseSseLine(currentData);
+            if (event) yield event;
+            currentData = "";
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function anySignal(signals) {
+  const controller = new AbortController();
+  for (const signal of signals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+
+// src/client.ts
+var asString = (v) => typeof v === "string" && v.trim().length > 0 ? v : null;
+var parseRunId = (payload) => {
+  try {
+    const id = idNormalizer.parse(payload);
+    if (id) return id;
+  } catch {
+    const nested = payload.run || null;
+    if (nested) {
+      try {
+        const id2 = idNormalizer.parse(nested);
+        if (id2) return id2;
+      } catch {
+      }
+    }
+  }
+  throw new Error("Run ID missing in engine response");
+};
+var TandemClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.token = options.token;
+    this.timeoutMs = options.timeoutMs ?? 2e4;
+    const req = this._request.bind(this);
+    this.sessions = new Sessions(this.baseUrl, this.token, this.timeoutMs, req);
+    this.permissions = new Permissions(req);
+    this.questions = new Questions(req);
+    this.providers = new Providers(req);
+    this.channels = new Channels(req);
+    this.mcp = new Mcp(req);
+    this.routines = new Routines(req);
+    this.automations = new Automations(req);
+    this.memory = new Memory(req);
+    this.skills = new Skills(req);
+    this.resources = new Resources(req);
+    this.agentTeams = new AgentTeams(req);
+    this.missions = new Missions(req);
+  }
+  // ─── Health ───────────────────────────────────────────────────────────────
+  /** Check engine health. Returns `{ ready: true }` when the engine is ready. */
+  async health() {
+    const raw = await this._request("/global/health");
+    return parseResponse(SystemHealthSchema, raw, "/global/health", 200);
+  }
+  // ─── Tools ────────────────────────────────────────────────────────────────
+  /** List all tool IDs registered in the engine. */
+  async listToolIds() {
+    return this._request("/tool/ids");
+  }
+  /** List all tools with their schemas. */
+  async listTools() {
+    const raw = await this._request("/tool");
+    return Array.isArray(raw) ? raw : [];
+  }
+  /**
+   * Execute a built-in tool directly (without a session).
+   *
+   * @example
+   * ```typescript
+   * const result = await client.executeTool("workspace_list_files", { path: "." });
+   * console.log(result.output);
+   * ```
+   */
+  async executeTool(tool, args) {
+    return this._request("/tool/execute", {
+      method: "POST",
+      body: JSON.stringify({ tool, args: args ?? {} })
+    });
+  }
+  // ─── SSE streaming ────────────────────────────────────────────────────────
+  /**
+   * Stream events from an active run as an async generator.
+   *
+   * @example
+   * ```typescript
+   * for await (const event of client.stream(sessionId, runId)) {
+   *   if (event.type === "session.response") {
+   *     process.stdout.write(String(event.properties.delta ?? ""));
+   *   }
+   *   if (event.type === "run.complete" || event.type === "run.failed") break;
+   * }
+   * ```
+   */
+  stream(sessionId, runId, options) {
+    const params = new URLSearchParams({ sessionID: sessionId });
+    if (runId) params.set("runID", runId);
+    const url = `${this.baseUrl}/event?${params.toString()}`;
+    return streamSse(url, this.token, options);
+  }
+  /**
+   * Stream the global event feed (all sessions).
+   */
+  globalStream(options) {
+    const url = `${this.baseUrl}/global/event`;
+    return streamSse(url, this.token, options);
+  }
+  /**
+   * Pull stored events for a specific run (paginated, not SSE).
+   */
+  async runEvents(runId, options) {
+    const params = new URLSearchParams();
+    if (options?.sinceSeq !== void 0) params.set("since_seq", String(options.sinceSeq));
+    if (options?.tail !== void 0) params.set("tail", String(options.tail));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    const raw = await this._request(`/run/${encodeURIComponent(runId)}/events${qs}`);
+    return Array.isArray(raw) ? raw : [];
+  }
+  // ─── Internal HTTP ────────────────────────────────────────────────────────
+  async _request(path, init = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let res;
+    try {
+      res = await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.token}`,
+          ...init.headers ?? {}
+        },
+        signal: controller.signal
+      });
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`Request timed out after ${this.timeoutMs}ms: ${path}`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (res.status === 204) return void 0;
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`Request failed (${res.status} ${res.statusText}): ${body}`);
+    }
+    return res.json();
+  }
+};
+var Sessions = class {
+  constructor(baseUrl, token, timeoutMs, req) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+    this.timeoutMs = timeoutMs;
+    this.req = req;
+  }
+  /** Create a new session. Returns the session ID. */
+  async create(options = {}) {
+    const payload = {
+      title: options.title ?? "Tandem SDK Session",
+      directory: options.directory ?? "."
+    };
+    if (options.permissions) payload.permission = options.permissions;
+    if (options.model && options.provider) {
+      payload.model = { providerID: options.provider, modelID: options.model };
+      payload.provider = options.provider;
+    }
+    const data = await this.req("/session", {
+      method: "POST",
+      body: JSON.stringify(payload)
+    });
+    return data.id;
+  }
+  /** List sessions with optional filtering. */
+  async list(options = {}) {
+    const params = new URLSearchParams();
+    if (options.q) params.set("q", options.q);
+    if (options.page !== void 0) params.set("page", String(options.page));
+    if (options.pageSize !== void 0) params.set("page_size", String(options.pageSize));
+    if (options.archived !== void 0) params.set("archived", String(options.archived));
+    if (options.scope) params.set("scope", options.scope);
+    if (options.workspace) params.set("workspace", options.workspace);
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    const raw = await this.req(`/session${qs}`);
+    return parseResponse(SessionListResponseSchema, raw, "/session", 200);
+  }
+  /** Get a session by ID. */
+  async get(sessionId) {
+    const raw = await this.req(`/session/${encodeURIComponent(sessionId)}`);
+    return parseResponse(SessionRecordSchema, raw, `/session/${sessionId}`, 200);
+  }
+  /** Update session metadata (title, archive status). */
+  async update(sessionId, options) {
+    const raw = await this.req(`/session/${encodeURIComponent(sessionId)}`, {
+      method: "PATCH",
+      body: JSON.stringify(options)
+    });
+    return parseResponse(SessionRecordSchema, raw, `/session/${sessionId}`, 200);
+  }
+  /** Archive a session (shorthand for `update(id, { archived: true })`). */
+  async archive(sessionId) {
+    return this.update(sessionId, { archived: true });
+  }
+  /** Delete a session permanently. */
+  async delete(sessionId) {
+    await this.req(`/session/${encodeURIComponent(sessionId)}`, { method: "DELETE" });
+  }
+  /** Get all messages in a session. */
+  async messages(sessionId) {
+    return this.req(`/session/${encodeURIComponent(sessionId)}/message`);
+  }
+  /** Get pending TODOs associated with a session. */
+  async todos(sessionId) {
+    const raw = await this.req(`/session/${encodeURIComponent(sessionId)}/todo`);
+    if (Array.isArray(raw)) return raw;
+    const wrapped = raw;
+    return wrapped.todos ?? [];
+  }
+  /** Get the currently active run for a session (if any). */
+  async activeRun(sessionId) {
+    const raw = await this.req(`/session/${encodeURIComponent(sessionId)}/run`);
+    return parseResponse(SessionRunStateResponseSchema, raw, `/session/${sessionId}/run`, 200);
+  }
+  /**
+   * Start an async run and return the run ID.
+   * Use `client.stream(sessionId, runId)` to receive events.
+   *
+   * Handles 409 SESSION_RUN_CONFLICT by returning the existing run ID.
+   */
+  async promptAsync(sessionId, prompt) {
+    const payload = { parts: [{ type: "text", text: prompt }] };
+    const path = `/session/${encodeURIComponent(sessionId)}/prompt_async?return=run`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let res;
+    try {
+      res = await fetch(`${this.baseUrl}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.token}`
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (res.status === 409) {
+      const conflict = await res.json().catch(() => ({}));
+      const active = conflict.activeRun;
+      const conflictId = asString(active?.runID) || asString(active?.runId) || asString(active?.run_id);
+      if (conflictId) return { runId: conflictId };
+    }
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`promptAsync failed (${res.status}): ${body}`);
+    }
+    const data = await res.json();
+    return { runId: parseRunId(data) };
+  }
+  /**
+   * Run a prompt synchronously and return the text reply (blocking).
+   * For long tasks prefer `promptAsync` + `stream()`.
+   */
+  async promptSync(sessionId, prompt) {
+    const payload = { parts: [{ type: "text", text: prompt }] };
+    const data = await this.req(
+      `/session/${encodeURIComponent(sessionId)}/prompt_sync`,
+      { method: "POST", body: JSON.stringify(payload) }
+    );
+    return asString(data.reply) || asString(data.text) || asString(data.output) || "";
+  }
+  /**
+   * Abort the active run for a session.
+   */
+  async abort(sessionId) {
+    return this.req(`/session/${encodeURIComponent(sessionId)}/abort`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  /**
+   * Cancel the session's active run (alias of abort on some engine versions).
+   */
+  async cancel(sessionId) {
+    return this.req(`/session/${encodeURIComponent(sessionId)}/cancel`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  /**
+   * Cancel a specific run within a session.
+   */
+  async cancelRun(sessionId, runId) {
+    return this.req(
+      `/session/${encodeURIComponent(sessionId)}/run/${encodeURIComponent(runId)}/cancel`,
+      { method: "POST", body: JSON.stringify({}) }
+    );
+  }
+  /**
+   * Fork a session into a child session (divergent conversation branch).
+   */
+  async fork(sessionId) {
+    const raw = await this.req(`/session/${encodeURIComponent(sessionId)}/fork`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+    return parseResponse(SessionRecordSchema, raw, `/session/${sessionId}/fork`, 200);
+  }
+  /**
+   * Get the workspace diff produced by the session's last run.
+   */
+  async diff(sessionId) {
+    return this.req(`/session/${encodeURIComponent(sessionId)}/diff`);
+  }
+  /**
+   * Revert uncommitted workspace changes made by the session.
+   */
+  async revert(sessionId) {
+    return this.req(`/session/${encodeURIComponent(sessionId)}/revert`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  /**
+   * Undo a previous revert (restore session changes).
+   */
+  async unrevert(sessionId) {
+    return this.req(`/session/${encodeURIComponent(sessionId)}/unrevert`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  /**
+   * Get child sessions forked from this session.
+   */
+  async children(sessionId) {
+    const raw = await this.req(`/session/${encodeURIComponent(sessionId)}/children`);
+    const parsed = parseResponse(SessionListResponseSchema, raw, `/session/${sessionId}/children`, 200);
+    return parsed.sessions;
+  }
+  /**
+   * Trigger an engine-side summarization of the session's conversation history.
+   */
+  async summarize(sessionId) {
+    return this.req(
+      `/session/${encodeURIComponent(sessionId)}/summarize`,
+      { method: "POST", body: JSON.stringify({}) }
+    );
+  }
+  /**
+   * Attach a session to a different workspace directory.
+   */
+  async attach(sessionId, targetWorkspace) {
+    return this.req(`/session/${encodeURIComponent(sessionId)}/attach`, {
+      method: "POST",
+      body: JSON.stringify({ target_workspace: targetWorkspace })
+    });
+  }
+};
+var Permissions = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List all pending permission requests and existing rules. */
+  async list() {
+    return this.req("/permission");
+  }
+  /** Reply to a permission request. Use "always" to auto-approve future requests. */
+  async reply(requestId, reply) {
+    const res = await this.req(
+      `/permission/${encodeURIComponent(requestId)}/reply`,
+      { method: "POST", body: JSON.stringify({ reply }) }
+    );
+    if (!res.ok) throw new Error(`Permission reply rejected: ${res.error ?? requestId}`);
+    return { ok: true };
+  }
+};
+var Questions = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List pending AI-generated questions awaiting user confirmation. */
+  async list() {
+    const raw = await this.req("/question");
+    if (Array.isArray(raw)) return { questions: raw };
+    return raw;
+  }
+  /** Answer a pending question. */
+  async reply(questionId, answer) {
+    return this.req(`/question/${encodeURIComponent(questionId)}/reply`, {
+      method: "POST",
+      body: JSON.stringify({ answer })
+    });
+  }
+  /** Reject/dismiss a pending question. */
+  async reject(questionId) {
+    return this.req(`/question/${encodeURIComponent(questionId)}/reject`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+};
+var Providers = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List all available providers and their models. */
+  async catalog() {
+    return this.req("/provider");
+  }
+  /** Get the current provider/model configuration. */
+  async config() {
+    return this.req("/config/providers");
+  }
+  /** Set the default provider and model. */
+  async setDefaults(providerId, modelId) {
+    await this.req("/config", {
+      method: "PATCH",
+      body: JSON.stringify({
+        default_provider: providerId,
+        providers: { [providerId]: { default_model: modelId } }
+      })
+    });
+  }
+  /** Store an API key for a provider. */
+  async setApiKey(providerId, apiKey) {
+    await this.req(`/auth/${encodeURIComponent(providerId)}`, {
+      method: "PUT",
+      body: JSON.stringify({ apiKey })
+    });
+  }
+  /** Get authentication status for a provider. */
+  async authStatus() {
+    return this.req("/provider/auth");
+  }
+};
+var Channels = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** Get channel configuration (Telegram / Discord / Slack). */
+  async config() {
+    return this.req("/channels/config");
+  }
+  /** Get live channel connection status. */
+  async status() {
+    return this.req("/channels/status");
+  }
+  /** Configure a channel (bot token, allowed users, etc.). */
+  async put(channel, payload) {
+    return this.req(`/channels/${channel}`, {
+      method: "PUT",
+      body: JSON.stringify(payload)
+    });
+  }
+  /** Remove a channel configuration. */
+  async delete(channel) {
+    return this.req(`/channels/${channel}`, { method: "DELETE" });
+  }
+};
+var Mcp = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List registered MCP servers. */
+  async list() {
+    return this.req("/mcp");
+  }
+  /** List all discovered MCP tools. */
+  async listTools() {
+    return this.req("/mcp/tools");
+  }
+  /** List all discovered MCP resources. */
+  async listResources() {
+    const raw = await this.req("/mcp/resources");
+    return Array.isArray(raw) ? raw : [];
+  }
+  /**
+   * Register a new MCP server.
+   *
+   * @example
+   * ```typescript
+   * await client.mcp.add({ name: "arcade", transport: "https://mcp.arcade.ai/mcp" });
+   * await client.mcp.connect("arcade");
+   * ```
+   */
+  async add(options) {
+    return this.req("/mcp", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /** Connect to an MCP server and discover its tools. */
+  async connect(name) {
+    return this.req(`/mcp/${encodeURIComponent(name)}/connect`, {
+      method: "POST"
+    });
+  }
+  /** Disconnect from an MCP server. */
+  async disconnect(name) {
+    return this.req(`/mcp/${encodeURIComponent(name)}/disconnect`, {
+      method: "POST"
+    });
+  }
+  /** Re-discover tools from a connected MCP server. */
+  async refresh(name) {
+    return this.req(
+      `/mcp/${encodeURIComponent(name)}/refresh`,
+      { method: "POST" }
+    );
+  }
+  /** Enable or disable an MCP server. */
+  async setEnabled(name, enabled) {
+    return this.req(`/mcp/${encodeURIComponent(name)}`, {
+      method: "PATCH",
+      body: JSON.stringify({ enabled })
+    });
+  }
+};
+var Memory = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /**
+   * Store a memory item.
+   *
+   * @example
+   * ```typescript
+   * await client.memory.put({
+   *   text: "The team uses Rust for backend services.",
+   *   tags: ["team", "architecture"],
+   * });
+   * ```
+   */
+  async put(options) {
+    return this.req("/memory/put", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /**
+   * Semantic search over stored memories.
+   *
+   * @example
+   * ```typescript
+   * const { results } = await client.memory.search({
+   *   query: "backend technology choices",
+   *   limit: 5,
+   * });
+   * ```
+   */
+  async search(options) {
+    const raw = await this.req("/memory/search", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+    return parseResponse(MemorySearchResponseSchema, raw, "/memory/search", 200);
+  }
+  /** List stored memory items with optional text filter. */
+  async list(options) {
+    const params = new URLSearchParams();
+    if (options?.q) params.set("q", options.q);
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    if (options?.offset !== void 0) params.set("offset", String(options.offset));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    const raw = await this.req(`/memory${qs}`);
+    return parseResponse(MemoryListResponseSchema, raw, "/memory", 200);
+  }
+  /** Delete a memory item by ID. */
+  async delete(memoryId) {
+    return this.req(`/memory/${encodeURIComponent(memoryId)}`, {
+      method: "DELETE"
+    });
+  }
+  /** Promote a transient memory item to persistent storage. */
+  async promote(options) {
+    return this.req("/memory/promote", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /** Retrieve the memory audit log for a run. */
+  async audit(options) {
+    const params = new URLSearchParams();
+    if (options?.run_id) params.set("run_id", options.run_id);
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    const raw = await this.req(`/memory/audit${qs}`);
+    if (Array.isArray(raw)) return { entries: raw, count: raw.length };
+    return raw;
+  }
+};
+var Skills = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List installed agent skills. */
+  async list(location) {
+    const qs = location ? `?location=${encodeURIComponent(location)}` : "";
+    const raw = await this.req(`/skills${qs}`);
+    if (Array.isArray(raw)) return { skills: raw, count: raw.length };
+    return raw;
+  }
+  /** Get details of a specific skill by name. */
+  async get(name) {
+    return this.req(`/skills/${encodeURIComponent(name)}`);
+  }
+  /** Import a skill from YAML content or a file path. */
+  async import(options) {
+    return this.req("/skills/import", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /** Preview a skill import (dry run). */
+  async preview(options) {
+    return this.req("/skills/import/preview", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /** List available skill templates shipped with the engine. */
+  async templates() {
+    const raw = await this.req("/skills/templates");
+    if (Array.isArray(raw)) return { templates: raw, count: raw.length };
+    return raw;
+  }
+};
+var Resources = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List stored resource records. */
+  async list(options) {
+    const params = new URLSearchParams();
+    if (options?.prefix) params.set("prefix", options.prefix);
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    const raw = await this.req(`/resource${qs}`);
+    return parseResponse(ResourceListResponseSchema, raw, "/resource", 200);
+  }
+  /**
+   * Write a resource key-value entry.
+   *
+   * @example
+   * ```typescript
+   * await client.resources.write({
+   *   key: "agent-config/alert-threshold",
+   *   value: { threshold: 0.95 },
+   * });
+   * ```
+   */
+  async write(options) {
+    return this.req("/resource", {
+      method: "PUT",
+      body: JSON.stringify(options)
+    });
+  }
+  /** Delete a resource entry. */
+  async delete(key, options) {
+    return this.req("/resource", {
+      method: "DELETE",
+      body: JSON.stringify({ key, ...options })
+    });
+  }
+};
+var Routines = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List all scheduled routines. */
+  async list() {
+    return this.req("/routines");
+  }
+  /**
+   * Create a scheduled routine.
+   *
+   * @example
+   * ```typescript
+   * await client.routines.create({
+   *   name: "Daily digest",
+   *   schedule: "0 8 * * *",
+   *   entrypoint: "Summarize activity from the last 24 hours",
+   * });
+   * ```
+   */
+  async create(options) {
+    const payload = { ...options };
+    if ("prompt" in payload && !("entrypoint" in payload)) {
+      payload.entrypoint = payload.prompt;
+    }
+    return this.req("/routines", {
+      method: "POST",
+      body: JSON.stringify(payload)
+    });
+  }
+  /** Update a routine (partial patch). */
+  async update(id, patch) {
+    return this.req(`/routines/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body: JSON.stringify(patch)
+    });
+  }
+  /** Delete a routine by ID. */
+  async delete(id) {
+    await this.req(`/routines/${encodeURIComponent(id)}`, { method: "DELETE" });
+  }
+  /** Trigger a routine immediately (run now). */
+  async runNow(id) {
+    const raw = await this.req(`/routines/${encodeURIComponent(id)}/run_now`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+    return parseResponse(RunNowResponseSchema, raw, `/routines/${id}/run_now`, 200);
+  }
+  /** List recent runs across all routines. */
+  async listRuns(options) {
+    const params = new URLSearchParams();
+    if (options?.routine_id) params.set("routine_id", options.routine_id);
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return this.req(`/routines/runs${qs}`);
+  }
+  /** List runs for a specific routine. */
+  async getRunsForRoutine(id, limit = 25) {
+    return this.req(`/routines/${encodeURIComponent(id)}/runs?limit=${limit}`);
+  }
+  /** Get a specific run record. */
+  async getRun(runId) {
+    const raw = await this.req(`/routines/runs/${encodeURIComponent(runId)}`);
+    return parseResponse(RunRecordSchema, raw, `/routines/runs/${runId}`, 200);
+  }
+  /** List artifacts produced by a run. */
+  async listArtifacts(runId) {
+    return this.req(`/routines/runs/${encodeURIComponent(runId)}/artifacts`);
+  }
+  /** Approve a run that requires human approval. */
+  async approveRun(runId, reason) {
+    return this.req(`/routines/runs/${encodeURIComponent(runId)}/approve`, {
+      method: "POST",
+      body: JSON.stringify({ reason: reason ?? "" })
+    });
+  }
+  /** Deny a run that requires human approval. */
+  async denyRun(runId, reason) {
+    return this.req(`/routines/runs/${encodeURIComponent(runId)}/deny`, {
+      method: "POST",
+      body: JSON.stringify({ reason: reason ?? "" })
+    });
+  }
+  /** Pause an active run. */
+  async pauseRun(runId, reason) {
+    return this.req(`/routines/runs/${encodeURIComponent(runId)}/pause`, {
+      method: "POST",
+      body: JSON.stringify({ reason: reason ?? "" })
+    });
+  }
+  /** Resume a paused run. */
+  async resumeRun(runId, reason) {
+    return this.req(`/routines/runs/${encodeURIComponent(runId)}/resume`, {
+      method: "POST",
+      body: JSON.stringify({ reason: reason ?? "" })
+    });
+  }
+  /** Get execution history for a routine. */
+  async history(id, limit) {
+    const qs = limit !== void 0 ? `?limit=${limit}` : "";
+    const raw = await this.req(`/routines/${encodeURIComponent(id)}/history${qs}`);
+    if (Array.isArray(raw)) return { history: raw, count: raw.length };
+    return raw;
+  }
+};
+var Automations = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List all automations. */
+  async list() {
+    return this.req("/automations");
+  }
+  /**
+   * Create a mission-scoped automation.
+   *
+   * @example
+   * ```typescript
+   * await client.automations.create({
+   *   name: "Weekly security scan",
+   *   schedule: "0 9 * * 1",  // every Monday 9am
+   *   mission: {
+   *     objective: "Run a security audit of the API surface",
+   *     success_criteria: ["No critical vulnerabilities", "Report written to reports/security.md"],
+   *   },
+   *   policy: {
+   *     tool: { external_integrations_allowed: false },
+   *     approval: { requires_approval: true },
+   *   },
+   * });
+   * ```
+   */
+  async create(options) {
+    return this.req("/automations", {
+      method: "POST",
+      body: JSON.stringify(options)
+    });
+  }
+  /** Update an automation (partial patch). */
+  async update(id, patch) {
+    return this.req(`/automations/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body: JSON.stringify(patch)
+    });
+  }
+  /** Delete an automation. */
+  async delete(id) {
+    await this.req(`/automations/${encodeURIComponent(id)}`, { method: "DELETE" });
+  }
+  /** Trigger an automation immediately. */
+  async runNow(id) {
+    const raw = await this.req(`/automations/${encodeURIComponent(id)}/run_now`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+    return parseResponse(RunNowResponseSchema, raw, `/automations/${id}/run_now`, 200);
+  }
+  /** List recent runs across all automations. */
+  async listRuns(options) {
+    const params = new URLSearchParams();
+    if (options?.automation_id) params.set("automation_id", options.automation_id);
+    if (options?.limit !== void 0) params.set("limit", String(options.limit));
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return this.req(`/automations/runs${qs}`);
+  }
+  /** List runs for a specific automation. */
+  async getRunsForAutomation(id, limit = 25) {
+    return this.req(`/automations/${encodeURIComponent(id)}/runs?limit=${limit}`);
+  }
+  /** Get a specific automation run record. */
+  async getRun(runId) {
+    const raw = await this.req(`/automations/runs/${encodeURIComponent(runId)}`);
+    return parseResponse(RunRecordSchema, raw, `/automations/runs/${runId}`, 200);
+  }
+  /** List artifacts from an automation run. */
+  async listArtifacts(runId) {
+    return this.req(`/automations/runs/${encodeURIComponent(runId)}/artifacts`);
+  }
+  /** Approve an automation run pending human review. */
+  async approveRun(runId, reason) {
+    return this.req(`/automations/runs/${encodeURIComponent(runId)}/approve`, {
+      method: "POST",
+      body: JSON.stringify({ reason: reason ?? "" })
+    });
+  }
+  /** Deny an automation run pending human review. */
+  async denyRun(runId, reason) {
+    return this.req(`/automations/runs/${encodeURIComponent(runId)}/deny`, {
+      method: "POST",
+      body: JSON.stringify({ reason: reason ?? "" })
+    });
+  }
+  /** Pause an active automation run. */
+  async pauseRun(runId, reason) {
+    return this.req(`/automations/runs/${encodeURIComponent(runId)}/pause`, {
+      method: "POST",
+      body: JSON.stringify({ reason: reason ?? "" })
+    });
+  }
+  /** Resume a paused automation run. */
+  async resumeRun(runId, reason) {
+    return this.req(`/automations/runs/${encodeURIComponent(runId)}/resume`, {
+      method: "POST",
+      body: JSON.stringify({ reason: reason ?? "" })
+    });
+  }
+  /** Get execution history for an automation. */
+  async history(id, limit) {
+    const qs = limit !== void 0 ? `?limit=${limit}` : "";
+    const raw = await this.req(`/automations/${encodeURIComponent(id)}/history${qs}`);
+    if (Array.isArray(raw)) return { history: raw, count: raw.length };
+    return raw;
+  }
+};
+var AgentTeams = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List available agent team templates. */
+  async listTemplates() {
+    return this.req("/agent-team/templates");
+  }
+  /** List agent team instances. */
+  async listInstances(options) {
+    const params = new URLSearchParams();
+    if (options?.missionID) params.set("missionID", options.missionID);
+    if (options?.parentInstanceID) params.set("parentInstanceID", options.parentInstanceID);
+    if (options?.status) params.set("status", options.status);
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    return this.req(`/agent-team/instances${qs}`);
+  }
+  /** List missions managed by the agent team orchestrator. */
+  async listMissions() {
+    return this.req("/agent-team/missions");
+  }
+  /** List pending spawn and tool approvals. */
+  async listApprovals() {
+    return this.req("/agent-team/approvals");
+  }
+  /**
+   * Spawn a new agent team instance.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.agentTeams.spawn({
+   *   missionID: "mission-123",
+   *   role: "builder",
+   *   justification: "Implementing feature X as planned",
+   * });
+   * ```
+   */
+  async spawn(input) {
+    return this.req("/agent-team/spawn", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  /** Approve a pending agent team spawn request. */
+  async approveSpawn(approvalId, reason) {
+    return this.req(
+      `/agent-team/approvals/spawn/${encodeURIComponent(approvalId)}/approve`,
+      { method: "POST", body: JSON.stringify({ reason: reason ?? "" }) }
+    );
+  }
+  /** Deny a pending agent team spawn request. */
+  async denySpawn(approvalId, reason) {
+    return this.req(
+      `/agent-team/approvals/spawn/${encodeURIComponent(approvalId)}/deny`,
+      { method: "POST", body: JSON.stringify({ reason: reason ?? "" }) }
+    );
+  }
+};
+var Missions = class {
+  constructor(req) {
+    this.req = req;
+  }
+  /** List all missions. */
+  async list() {
+    return this.req("/mission");
+  }
+  /**
+   * Create a new mission with work items.
+   *
+   * @example
+   * ```typescript
+   * const { mission } = await client.missions.create({
+   *   title: "Q1 Security Hardening",
+   *   goal: "Audit and fix security issues in the API surface",
+   *   work_items: [
+   *     { title: "Audit auth middleware", assigned_agent: "security-auditor" },
+   *     { title: "Review input validation", assigned_agent: "security-auditor" },
+   *   ],
+   * });
+   * ```
+   */
+  async create(input) {
+    return this.req("/mission", {
+      method: "POST",
+      body: JSON.stringify(input)
+    });
+  }
+  /** Get a mission by ID. */
+  async get(missionId) {
+    return this.req(`/mission/${encodeURIComponent(missionId)}`);
+  }
+  /** Apply a state event to a mission. */
+  async applyEvent(missionId, event) {
+    return this.req(`/mission/${encodeURIComponent(missionId)}/event`, {
+      method: "POST",
+      body: JSON.stringify({ event })
+    });
+  }
+};
+export {
+  TandemClient,
+  TandemValidationError,
+  filterByType,
+  on,
+  streamSse
+};