@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/toolIntegration.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Which integration an MCP tool call went through. Resolved where the agent
+ * event is parsed (tool args are available there), then stored on the chat
+ * message so the UI never has to guess from display text.
+ */
+export interface ToolIntegrationRef {
+    /** MCP server the call went through, e.g. `steer_hub` or a user's own server. */
+    server: string;
+    /**
+     * Integration id for the logo/label: the hub provider (`gmail`, `slack`, …),
+     * `steer` for hub meta-tools with no provider, or the server name for
+     * non-hub MCP servers.
+     */
+    provider: string;
+    /** Tool within the provider, e.g. `send_email`. */
+    tool: string;
+}
+/** Provider id used for Integrations Hub meta-tools that name no app. */
+export declare const STEER_HUB_PROVIDER = "steer";
+export declare const HUB_SEARCH_TOOLS = "search_tools";
+export declare const HUB_CALL_TOOL = "call_tool";
+/** Hub server name, including the pre-rename one and client-added prefixes. */
+export declare function isSteerHubServer(server: string): boolean;
+/** Resolve the integration behind one MCP call on `server` → `tool(args)`. */
+export declare function resolveMcpToolRef(serverRaw: string, toolRaw: string, argsRaw?: unknown): ToolIntegrationRef | undefined;
+/** Claude Code names MCP tools `mcp__<server>__<tool>`. */
+export declare function parseClaudeMcpToolName(name: string): {
+    server: string;
+    tool: string;
+} | null;
+/** Claude Code tool_use → integration, or undefined for built-in tools. */
+export declare function claudeToolIntegration(name: string, input?: unknown): ToolIntegrationRef | undefined;
+/** Cursor `mcpToolCall` args: `{ providerIdentifier, toolName, args }`. */
+export declare function cursorToolIntegration(name: string, args?: Record<string, unknown>): ToolIntegrationRef | undefined;
+/** MCP server name for Eigen's room/run tools (`steer_upload_file`, orchestration, memory). */
+export declare const ROOM_MCP_SERVER_NAME = "steer_room";
+/**
+ * OpenCode names MCP tools `<server>_<tool>` (and may also expose the bare
+ * tool name when it is unique). Older builds used Claude's `mcp__` form.
+ */
+export declare function parseOpencodeMcpToolName(name: string): {
+    server: string;
+    tool: string;
+} | null;
+/** OpenCode MCP tool_use → integration, or undefined for built-in tools. */
+export declare function opencodeToolIntegration(name: string, input?: Record<string, unknown>): ToolIntegrationRef | undefined;
+/** Codex `mcp_tool_call` item: `{ server, tool, arguments }`. */
+export declare function codexToolIntegration(item: Record<string, unknown>): ToolIntegrationRef | undefined;
+/** Stored `messages.integration_json` → ref (ignores malformed rows). */
+export declare function parseToolIntegrationJson(raw: unknown): ToolIntegrationRef | undefined;
+/**
+ * Cursor CLI stream-json `tool_call` line → integration. Applied in
+ * backends/index.ts (cursor.ts is bundled into the web app and must not
+ * import runtime modules).
+ */
+export declare function cursorStreamLineIntegration(json: unknown): ToolIntegrationRef | undefined;

package/dist/shared/toolIntegration.js

@@ -0,0 +1,180 @@
+/** Provider id used for Integrations Hub meta-tools that name no app. */
+export const STEER_HUB_PROVIDER = "steer";
+export const HUB_SEARCH_TOOLS = "search_tools";
+export const HUB_CALL_TOOL = "call_tool";
+/** Hub server name, including the pre-rename one and client-added prefixes. */
+export function isSteerHubServer(server) {
+    return /steer[_-](hub|integrations)/i.test(server);
+}
+function asRecord(value) {
+    if (typeof value === "string") {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+/**
+ * `<provider>__<tool>` → parts. Mirrors splitBundledToolName in
+ * integrations.ts; kept local because the web bundle imports this file and
+ * Turbopack can't follow runtime `.js` → `.ts` imports.
+ */
+function splitBundledToolName(name) {
+    const i = name.indexOf("__");
+    if (i <= 0)
+        return null;
+    return { provider: name.slice(0, i), tool: name.slice(i + 2) };
+}
+function str(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+/** Resolve the integration behind one MCP call on `server` → `tool(args)`. */
+export function resolveMcpToolRef(serverRaw, toolRaw, argsRaw) {
+    const server = serverRaw.trim();
+    const tool = toolRaw.trim();
+    if (!server || !tool)
+        return undefined;
+    if (!isSteerHubServer(server)) {
+        // Eigen's own servers (room memory, swarm board) are Steer, not an app.
+        const provider = /^steer[_-]/i.test(server) ? STEER_HUB_PROVIDER : server.toLowerCase();
+        return { server, provider, tool };
+    }
+    const args = asRecord(argsRaw);
+    if (tool === HUB_CALL_TOOL) {
+        const split = splitBundledToolName(str(args?.name));
+        return split
+            ? { server, provider: split.provider.toLowerCase(), tool: split.tool }
+            : { server, provider: STEER_HUB_PROVIDER, tool };
+    }
+    if (tool === HUB_SEARCH_TOOLS) {
+        return { server, provider: str(args?.provider).toLowerCase() || STEER_HUB_PROVIDER, tool };
+    }
+    const split = splitBundledToolName(tool);
+    return split
+        ? { server, provider: split.provider.toLowerCase(), tool: split.tool }
+        : { server, provider: STEER_HUB_PROVIDER, tool };
+}
+/** Claude Code names MCP tools `mcp__<server>__<tool>`. */
+export function parseClaudeMcpToolName(name) {
+    const match = /^mcp__(.+?)__(.+)$/.exec(name.trim());
+    return match ? { server: match[1], tool: match[2] } : null;
+}
+/** Claude Code tool_use → integration, or undefined for built-in tools. */
+export function claudeToolIntegration(name, input) {
+    const parsed = parseClaudeMcpToolName(name);
+    return parsed ? resolveMcpToolRef(parsed.server, parsed.tool, input) : undefined;
+}
+/** Cursor `mcpToolCall` args: `{ providerIdentifier, toolName, args }`. */
+export function cursorToolIntegration(name, args) {
+    if (name.replace(/ToolCall$/i, "").toLowerCase() !== "mcp" || !args)
+        return undefined;
+    return resolveMcpToolRef(str(args.providerIdentifier), str(args.toolName), args.args);
+}
+/** MCP server name for Eigen's room/run tools (`steer_upload_file`, orchestration, memory). */
+export const ROOM_MCP_SERVER_NAME = "steer_room";
+/** Eigen's MCP servers, as OpenCode prefixes their tool names. */
+const OPENCODE_STEER_SERVERS = ["steer_room", "steer_hub", "steer_swarm"];
+/** Swarm board tools that OpenCode may expose without the server prefix. */
+const OPENCODE_SWARM_TOOLS = new Set([
+    "team_list",
+    "board_digest",
+    "board_read",
+    "board_post",
+    "ask_orchestrator",
+    "request_human",
+    "task_list",
+    "task_claim",
+    "task_complete",
+    "notes_write",
+    "ledger_read",
+    "artifact_put",
+    "artifact_list",
+    "artifact_get",
+    "hypothesis_list",
+    "hypothesis_propose",
+    "hypothesis_critique",
+    "record_match",
+    "verify_result",
+    "create_task",
+    "update_task",
+    "spawn_worker",
+    "retire_worker",
+    "update_ledger",
+    "set_hypothesis_status",
+    "request_phase_change",
+    "declare_done",
+]);
+const OPENCODE_HUB_META_TOOLS = new Set([HUB_SEARCH_TOOLS, HUB_CALL_TOOL]);
+/**
+ * OpenCode names MCP tools `<server>_<tool>` (and may also expose the bare
+ * tool name when it is unique). Older builds used Claude's `mcp__` form.
+ */
+export function parseOpencodeMcpToolName(name) {
+    const trimmed = name.trim();
+    const legacy = parseClaudeMcpToolName(trimmed);
+    if (legacy)
+        return legacy;
+    for (const server of OPENCODE_STEER_SERVERS) {
+        const prefix = `${server}_`;
+        if (trimmed.startsWith(prefix) && trimmed.length > prefix.length) {
+            return { server, tool: trimmed.slice(prefix.length) };
+        }
+    }
+    // Hub aliases keep `<provider>__<tool>` without their `steer_hub_` prefix.
+    if (OPENCODE_HUB_META_TOOLS.has(trimmed) || splitBundledToolName(trimmed)) {
+        return { server: "steer_hub", tool: trimmed };
+    }
+    if (OPENCODE_SWARM_TOOLS.has(trimmed)) {
+        return { server: "steer_swarm", tool: trimmed };
+    }
+    // Room MCP tool names already start with `steer_`.
+    if (/^steer_/i.test(trimmed)) {
+        return { server: "steer_room", tool: trimmed };
+    }
+    return null;
+}
+/** OpenCode MCP tool_use → integration, or undefined for built-in tools. */
+export function opencodeToolIntegration(name, input) {
+    const parsed = parseOpencodeMcpToolName(name);
+    return parsed ? resolveMcpToolRef(parsed.server, parsed.tool, input) : undefined;
+}
+/** Codex `mcp_tool_call` item: `{ server, tool, arguments }`. */
+export function codexToolIntegration(item) {
+    return resolveMcpToolRef(str(item.server), str(item.tool), item.arguments);
+}
+/** Stored `messages.integration_json` → ref (ignores malformed rows). */
+export function parseToolIntegrationJson(raw) {
+    if (typeof raw !== "string" || !raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed.server === "string" &&
+            typeof parsed.provider === "string" &&
+            typeof parsed.tool === "string"
+            ? { server: parsed.server, provider: parsed.provider, tool: parsed.tool }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Cursor CLI stream-json `tool_call` line → integration. Applied in
+ * backends/index.ts (cursor.ts is bundled into the web app and must not
+ * import runtime modules).
+ */
+export function cursorStreamLineIntegration(json) {
+    const ev = asRecord(json);
+    if (ev?.type !== "tool_call")
+        return undefined;
+    const toolCall = asRecord(ev.tool_call);
+    const mcp = asRecord(toolCall?.mcpToolCall);
+    if (!mcp)
+        return undefined;
+    return cursorToolIntegration("mcp", asRecord(mcp.args ?? mcp.input ?? mcp.parameters));
+}

package/dist/shared/typing.d.ts

@@ -0,0 +1,9 @@
+/** Format a chat-style typing line scoped to one agent. */
+export declare function formatTypingIndicator(names: string[], agentLabel: string): string;
+/** Aggregate typing across agents for the “All agents” chat view. */
+export declare function formatTypingIndicatorAll(typingByAgent: Record<string, Array<{
+    name: string;
+}>>, agents: Array<{
+    id: string;
+    label: string;
+}>): string;

package/dist/shared/typing.js

@@ -0,0 +1,37 @@
+/** Format a chat-style typing line scoped to one agent. */
+export function formatTypingIndicator(names, agentLabel) {
+    const clean = names.map((n) => n.trim()).filter(Boolean);
+    if (clean.length === 0)
+        return "";
+    const target = agentLabel.trim() || "the agent";
+    if (clean.length === 1)
+        return `${clean[0]} is typing to ${target}…`;
+    if (clean.length === 2) {
+        return `${clean[0]} and ${clean[1]} are typing to ${target}…`;
+    }
+    return `${clean[0]} and ${clean.length - 1} others are typing to ${target}…`;
+}
+/** Aggregate typing across agents for the “All agents” chat view. */
+export function formatTypingIndicatorAll(typingByAgent, agents) {
+    const labelById = new Map(agents.map((a) => [a.id, a.label]));
+    const entries = [];
+    for (const [agentId, users] of Object.entries(typingByAgent)) {
+        const agentLabel = labelById.get(agentId) || "agent";
+        for (const u of users || []) {
+            const name = (u.name || "").trim();
+            if (name)
+                entries.push({ name, agentLabel });
+        }
+    }
+    if (entries.length === 0)
+        return "";
+    if (entries.length === 1) {
+        return formatTypingIndicator([entries[0].name], entries[0].agentLabel);
+    }
+    const names = [...new Set(entries.map((e) => e.name))];
+    if (names.length === 1)
+        return `${names[0]} is typing…`;
+    if (names.length === 2)
+        return `${names[0]} and ${names[1]} are typing…`;
+    return `${names[0]} and ${names.length - 1} others are typing…`;
+}

package/dist/shared/uploads.d.ts

@@ -0,0 +1,31 @@
+/** Workspace-relative folder where Steer drops user attachments for local agents. */
+export declare const ATTACHMENT_DIR = ".steer-uploads";
+/** True when the attachment URL can be loaded without API auth (e.g. R2 public bucket). */
+export declare function isPublicHttpUrl(url: string): boolean;
+/**
+ * Public object URL (Cloudflare R2 / CDN), not the authenticated Render upload API.
+ * Those API paths look like `/api/rooms/:id/uploads/:fileId` even when absolutized.
+ */
+export declare function isDirectFileUrl(url: string): boolean;
+/** Return the URL only when it should be used as the file's public address. */
+export declare function directFileUrl(url: string | undefined | null): string | undefined;
+export declare function safeAttachmentFileName(name: string): string;
+export declare function contentDispositionInline(name: string): string;
+export declare function contentDispositionAttachment(name: string): string;
+export declare function safeContentType(mime: string, fallback?: string): string;
+/** Path the agent should Read, relative to the run cwd. */
+export declare function attachmentWorkspaceRelPath(id: string, name: string): string;
+/**
+ * Curl a composer file into the workspace. The Cursor cloud VM already has
+ * `STEER_UPLOAD_URL` and `STEER_UPLOAD_TOKEN`; the token is not written here.
+ */
+export declare function cursorCloudAttachmentCurl(fileId: string, relPath: string): string;
+export declare function isSafeAttachmentRelPath(relPath: string): boolean;
+export interface WorkerPromptAttachment {
+    id: string;
+    name: string;
+    mime: string;
+    relPath: string;
+    /** Base64 file bytes. */
+    data: string;
+}

package/dist/shared/uploads.js

@@ -0,0 +1,65 @@
+/** Workspace-relative folder where Steer drops user attachments for local agents. */
+export const ATTACHMENT_DIR = ".steer-uploads";
+/** True when the attachment URL can be loaded without API auth (e.g. R2 public bucket). */
+export function isPublicHttpUrl(url) {
+    return /^https?:\/\//i.test(url.trim());
+}
+/**
+ * Public object URL (Cloudflare R2 / CDN), not the authenticated Render upload API.
+ * Those API paths look like `/api/rooms/:id/uploads/:fileId` even when absolutized.
+ */
+export function isDirectFileUrl(url) {
+    const trimmed = url.trim();
+    if (!isPublicHttpUrl(trimmed))
+        return false;
+    try {
+        const path = new URL(trimmed).pathname;
+        return (!/^\/api\/rooms\/[^/]+\/uploads\//i.test(path) &&
+            !/^\/api\/issues\/[^/]+\/attachments\//i.test(path));
+    }
+    catch {
+        return false;
+    }
+}
+/** Return the URL only when it should be used as the file's public address. */
+export function directFileUrl(url) {
+    return url && isDirectFileUrl(url) ? url.trim() : undefined;
+}
+export function safeAttachmentFileName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 120) || "file";
+}
+/** HTTP header-safe Content-Disposition. Node rejects unicode in filename=. */
+function contentDisposition(kind, name) {
+    const fallback = safeAttachmentFileName(name);
+    const encoded = encodeURIComponent(name.replace(/[\r\n\0]+/g, " ").trim() || fallback);
+    return `${kind}; filename="${fallback}"; filename*=UTF-8''${encoded}`;
+}
+export function contentDispositionInline(name) {
+    return contentDisposition("inline", name);
+}
+export function contentDispositionAttachment(name) {
+    return contentDisposition("attachment", name);
+}
+export function safeContentType(mime, fallback = "application/octet-stream") {
+    const trimmed = mime.trim().toLowerCase();
+    return /^[\w.+-]+\/[\w.+-]+$/.test(trimmed) ? trimmed : fallback;
+}
+/** Path the agent should Read, relative to the run cwd. */
+export function attachmentWorkspaceRelPath(id, name) {
+    return `${ATTACHMENT_DIR}/${id}-${safeAttachmentFileName(name)}`.replace(/\\/g, "/");
+}
+/**
+ * Curl a composer file into the workspace. The Cursor cloud VM already has
+ * `STEER_UPLOAD_URL` and `STEER_UPLOAD_TOKEN`; the token is not written here.
+ */
+export function cursorCloudAttachmentCurl(fileId, relPath) {
+    const dest = relPath.replace(/"/g, "");
+    return (`mkdir -p .steer-uploads && curl -fsS -H "Authorization: Bearer $STEER_UPLOAD_TOKEN" ` +
+        `-o "${dest}" "\${STEER_UPLOAD_URL%/api/agent-artifacts}/api/agent-uploads/${encodeURIComponent(fileId)}"`);
+}
+export function isSafeAttachmentRelPath(relPath) {
+    const normalized = relPath.replace(/\\/g, "/");
+    return (normalized.startsWith(`${ATTACHMENT_DIR}/`) &&
+        !normalized.includes("..") &&
+        !normalized.startsWith("/"));
+}

package/dist/shared/voiceApprovals.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Phone-call approvals via Sarvam Instant Outbound.
+ * The in-room Approve/Deny button stays the source of truth; voice is a second channel.
+ */
+export declare const VOICE_DECISIONS: readonly ["approved", "denied"];
+export type VoiceDecision = (typeof VOICE_DECISIONS)[number];
+export type VoiceCallStatus = "dialing" | "connected" | "no_answer" | "busy" | "failed" | "completed";
+export interface VoiceApprovalSettings {
+    phoneE164: string | null;
+    phoneMasked: string | null;
+    optIn: boolean;
+    callingConfigured: boolean;
+}
+export interface VoiceApprovalDecisionBody {
+    approvalId: string;
+    decision: VoiceDecision;
+    token?: string;
+}
+/** Normalize user-entered phones to E.164. Bare 10-digit numbers are treated as India (+91). */
+export declare function normalizePhoneE164(raw: unknown): string | null;
+export declare function maskPhoneE164(phone: string | null | undefined): string | null;
+export declare function parseVoiceDecision(raw: unknown): VoiceDecision | null;
+/** Unwrap Sarvam API-tool envelopes and JSON-as-text bodies. */
+export declare function flattenVoiceWebhookBody(body: unknown): Record<string, unknown>;
+export declare function pickRawVoiceDecision(body: Record<string, unknown>, query?: Record<string, unknown>): unknown;
+/**
+ * Instant Outbound's terminal webhook (`status: connected`) includes the
+ * transcript. Use that when the mid-call API tool never posts /decision.
+ */
+export declare function extractCallWebhookDecision(body: Record<string, unknown>): {
+    decision: VoiceDecision | null;
+    source: "variables" | "transcript" | null;
+    userTurns: string[];
+};
+export declare function parseVoiceCallStatus(raw: unknown): VoiceCallStatus | null;
+export declare function isVoiceCallInFlight(status: string | null | undefined): boolean;

package/dist/shared/voiceApprovals.js

@@ -0,0 +1,229 @@
+/**
+ * Phone-call approvals via Sarvam Instant Outbound.
+ * The in-room Approve/Deny button stays the source of truth; voice is a second channel.
+ */
+export const VOICE_DECISIONS = ["approved", "denied"];
+const E164_RE = /^\+[1-9]\d{7,14}$/;
+/** Normalize user-entered phones to E.164. Bare 10-digit numbers are treated as India (+91). */
+export function normalizePhoneE164(raw) {
+    if (typeof raw !== "string")
+        return null;
+    let s = raw.trim();
+    if (!s)
+        return null;
+    s = s.replace(/[()\s.\-]/g, "");
+    if (s.startsWith("00"))
+        s = `+${s.slice(2)}`;
+    if (s.startsWith("0") && /^\d{11}$/.test(s)) {
+        s = `+91${s.slice(1)}`;
+    }
+    if (/^\d{10}$/.test(s))
+        s = `+91${s}`;
+    if (/^\d{11,15}$/.test(s))
+        s = `+${s}`;
+    if (!s.startsWith("+"))
+        return null;
+    if (!E164_RE.test(s))
+        return null;
+    return s;
+}
+export function maskPhoneE164(phone) {
+    const p = phone?.trim() || "";
+    if (!p)
+        return null;
+    if (p.length < 6)
+        return "••••";
+    return `${p.slice(0, 3)}••••${p.slice(-4)}`;
+}
+export function parseVoiceDecision(raw) {
+    if (typeof raw === "boolean")
+        return raw ? "approved" : "denied";
+    if (typeof raw === "number") {
+        if (raw === 1)
+            return "approved";
+        if (raw === 0)
+            return "denied";
+        return null;
+    }
+    const original = String(raw ?? "").trim();
+    if (!original)
+        return null;
+    const compact = original
+        .toLowerCase()
+        .replace(/[_\s-]+/g, "")
+        .replace(/[^a-z0-9]+/g, "");
+    if (compact === "approved" ||
+        compact === "approve" ||
+        compact === "yes" ||
+        compact === "y" ||
+        compact === "true" ||
+        compact === "ok" ||
+        compact === "okay" ||
+        compact === "goahead") {
+        return "approved";
+    }
+    if (compact === "denied" ||
+        compact === "deny" ||
+        compact === "no" ||
+        compact === "n" ||
+        compact === "false" ||
+        compact === "reject" ||
+        compact === "rejected" ||
+        compact === "stop") {
+        return "denied";
+    }
+    const text = original.toLowerCase();
+    const yes = /\b(approved?|yes|yeah|yep|yup|ok(?:ay)?|go\s*ahead|proceed|confirm(?:ed)?)\b/.test(text);
+    const no = /\b(den(?:y|ied)|no(?:pe)?|reject(?:ed)?|stop|cancel(?:led)?|don'?t)\b/.test(text);
+    if (yes && !no)
+        return "approved";
+    if (no && !yes)
+        return "denied";
+    return null;
+}
+const NESTED_BODY_KEYS = [
+    "data",
+    "payload",
+    "parameters",
+    "params",
+    "arguments",
+    "args",
+    "input",
+    "body",
+    "variables",
+    "agent_variables",
+    "tool",
+    "request",
+];
+const DECISION_KEYS = [
+    "decision",
+    "approved",
+    "result",
+    "choice",
+    "action",
+    "intent",
+    "verdict",
+    "outcome",
+    "user_decision",
+    "spoken_decision",
+    "answer",
+    "status",
+];
+const TRANSCRIPT_KEYS = [
+    "transcript",
+    "call_transcript",
+    "callTranscript",
+    "conversation",
+    "user_response",
+    "message",
+    "text",
+    "utterance",
+];
+/** Unwrap Sarvam API-tool envelopes and JSON-as-text bodies. */
+export function flattenVoiceWebhookBody(body) {
+    if (typeof body === "string") {
+        const trimmed = body.trim();
+        if (!trimmed)
+            return {};
+        try {
+            return flattenVoiceWebhookBody(JSON.parse(trimmed));
+        }
+        catch {
+            return { decision: trimmed };
+        }
+    }
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return {};
+    const rec = body;
+    let out = { ...rec };
+    for (const key of NESTED_BODY_KEYS) {
+        const inner = rec[key];
+        if (inner && typeof inner === "object" && !Array.isArray(inner)) {
+            out = { ...inner, ...out };
+        }
+    }
+    return out;
+}
+export function pickRawVoiceDecision(body, query) {
+    for (const key of DECISION_KEYS) {
+        const value = body[key] ?? query?.[key];
+        if (value === undefined || value === null || String(value).trim() === "") {
+            continue;
+        }
+        if (key === "status" && parseVoiceCallStatus(value))
+            continue;
+        return value;
+    }
+    for (const key of TRANSCRIPT_KEYS) {
+        const value = body[key];
+        if (typeof value === "string" && value.trim())
+            return value;
+    }
+    return undefined;
+}
+function userTranscriptTurns(raw) {
+    if (typeof raw === "string" && raw.trim())
+        return [raw.trim()];
+    if (!Array.isArray(raw))
+        return [];
+    const texts = [];
+    for (const turn of raw) {
+        if (!turn || typeof turn !== "object")
+            continue;
+        const rec = turn;
+        const role = String(rec.role || rec.speaker || "").toLowerCase();
+        if (role && role !== "user" && role !== "customer" && role !== "human") {
+            continue;
+        }
+        const text = String(rec.en_text || rec.text || rec.content || rec.transcript || "").trim();
+        if (text)
+            texts.push(text);
+    }
+    return texts;
+}
+/**
+ * Instant Outbound's terminal webhook (`status: connected`) includes the
+ * transcript. Use that when the mid-call API tool never posts /decision.
+ */
+export function extractCallWebhookDecision(body) {
+    const variableBags = [
+        body.final_agent_variables,
+        body.final_agent,
+        body.collected_variables,
+        body.extracted_data,
+    ];
+    for (const bag of variableBags) {
+        if (!bag || typeof bag !== "object" || Array.isArray(bag))
+            continue;
+        const raw = pickRawVoiceDecision(bag);
+        const decision = parseVoiceDecision(raw);
+        if (decision) {
+            return { decision, source: "variables", userTurns: [] };
+        }
+    }
+    const userTurns = userTranscriptTurns(body.interaction_transcript ?? body.transcript ?? body.turns);
+    for (let i = userTurns.length - 1; i >= 0; i--) {
+        const decision = parseVoiceDecision(userTurns[i]);
+        if (decision) {
+            return { decision, source: "transcript", userTurns };
+        }
+    }
+    return { decision: null, source: null, userTurns };
+}
+export function parseVoiceCallStatus(raw) {
+    const v = String(raw ?? "")
+        .trim()
+        .toLowerCase();
+    if (v === "dialing" ||
+        v === "connected" ||
+        v === "no_answer" ||
+        v === "busy" ||
+        v === "failed" ||
+        v === "completed") {
+        return v;
+    }
+    return null;
+}
+export function isVoiceCallInFlight(status) {
+    return status === "dialing" || status === "connected";
+}