@sapiom/harness 0.1.4 → 0.1.6

package/dist/core/definition-slug-resolver.js

@@ -0,0 +1,110 @@
+/**
+ * Serve-time enrichment: resolves a deployed agent's `definitionSlug` from the
+ * Sapiom Agents API by its `definitionId`. The registry only knows the id (from
+ * `sapiom.json`'s `{ "definitionId": "188" }`) — the slug lives server-side,
+ * keyed by id.
+ *
+ * Resolution is cached in-memory (id→slug is stable once deployed; a slug
+ * never changes for a given id) so repeat calls across requests are free.
+ * Null resolutions are NOT cached: a transient network failure should be
+ * retryable without a server restart.
+ *
+ * Mirrors `@sapiom/tools`'s DEFAULT_BASE_URL for the base URL resolution.
+ */
+/** Returns the agents API base URL, honouring the same env-var precedence as
+ *  @sapiom/tools's DEFAULT_BASE_URL. */
+export function resolveAgentsBaseUrl() {
+    return (process.env.SAPIOM_AGENTS_URL ??
+        process.env.SAPIOM_TOOLS_BASE ??
+        "https://tools.sapiom.ai");
+}
+/**
+ * Resolve the CORE surface base URL (`api.<env>`), distinct from the agents
+ * host (`tools.<env>`) resolved above. A run lives in the agents env, and any
+ * core-surface call for that run must target the MATCHING core env — otherwise
+ * a prod run queried against dev 401s. So we DERIVE the core host from the
+ * agents host (`tools.<env>` → `api.<env>`) rather than reading
+ * `SAPIOM_API_URL`, which in some setups points at a different env than the
+ * agents surface. An explicit `SAPIOM_CORE_URL` still wins for full control.
+ *
+ * Co-located with {@link resolveAgentsBaseUrl} (its sole dependency) so the two
+ * env-precedence helpers live together.
+ */
+export function resolveCoreBaseUrl() {
+    const override = process.env.SAPIOM_CORE_URL;
+    if (override)
+        return override;
+    const agents = resolveAgentsBaseUrl();
+    try {
+        const url = new URL(agents);
+        if (url.hostname.startsWith("tools.")) {
+            url.hostname = `api.${url.hostname.slice("tools.".length)}`;
+            return url.origin;
+        }
+    }
+    catch {
+        // Unparseable agents URL — fall through to the prod default.
+    }
+    return "https://api.sapiom.ai";
+}
+/**
+ * Creates a resolver that fetches `GET /agents/v1/definitions/<id>` with the
+ * caller's API key and returns the `slug` field from the response.
+ *
+ * Safe to call from any request handler: never throws, returns null on any
+ * failure (network, 4xx, missing field, unparseable body).
+ */
+export function createDefinitionSlugResolver(opts) {
+    const { apiKey, baseUrl = resolveAgentsBaseUrl(), fetchImpl = fetch } = opts;
+    const cache = new Map();
+    // Each id's resolution failure is logged at most once. resolve() runs on
+    // every /api/state and /api/workflows poll and null results are deliberately
+    // not cached (so a transient failure stays retryable), so without this a
+    // persistent failure — e.g. the harness signed into an account that can't
+    // see this agent — would reprint on every poll. One line per id is enough to
+    // diagnose why the snippet panel fell back to the project name.
+    const loggedFailures = new Set();
+    const warnOnce = (definitionId, reason) => {
+        if (loggedFailures.has(definitionId))
+            return;
+        loggedFailures.add(definitionId);
+        console.error(`[harness] could not resolve deployed-agent slug for definitionId=${definitionId} ` +
+            `at ${baseUrl} (${reason}); the snippet panel will fall back to the project name — ` +
+            `check the harness is signed into the account that owns this agent`);
+    };
+    return {
+        async resolve(definitionId) {
+            // Not signed in: expected (a harness launched without auth), not a
+            // failure worth logging — the panel's project-name fallback covers it.
+            if (!apiKey)
+                return null;
+            const cached = cache.get(definitionId);
+            if (cached !== undefined)
+                return cached;
+            try {
+                const url = `${baseUrl}/agents/v1/definitions/${encodeURIComponent(definitionId)}`;
+                const response = await fetchImpl(url, {
+                    headers: { "x-sapiom-api-key": apiKey },
+                });
+                if (!response.ok) {
+                    warnOnce(definitionId, `HTTP ${response.status}`);
+                    return null;
+                }
+                const body = (await response.json());
+                const slug = typeof body.slug === "string" ? body.slug : null;
+                if (slug !== null) {
+                    cache.set(definitionId, slug);
+                }
+                else {
+                    warnOnce(definitionId, "response had no string `slug` field");
+                }
+                return slug;
+            }
+            catch (err) {
+                warnOnce(definitionId, err instanceof Error ? err.message : String(err));
+                return null;
+            }
+        },
+    };
+}
+//# sourceMappingURL=definition-slug-resolver.js.map

package/dist/core/definition-slug-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition-slug-resolver.js","sourceRoot":"","sources":["../../src/core/definition-slug-resolver.ts"],"names":[],"mappings":"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"}

package/dist/core/execution-detector.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Execution detection — mirrors {@link PortDetector} (core/port-detector.ts).
+ *
+ * A run can start two ways in the harness, and this catches both:
+ *  1. The CLI prints `✓ Started execution <executionId>` (`sapiom agents run`).
+ *  2. The coding agent starts the run via the MCP run tool — the common path —
+ *     whose result carries the id as an `executionId` field
+ *     (`"executionId":"<id>"` / `executionId: <id>`).
+ * The detector is fed the SAME tool.call output PortDetector is (server/index.ts
+ * `onNormalizedEvent`, including the tool RESPONSE summary), so an MCP-triggered
+ * run is caught without changing how runs are triggered. It fires `onExecution`
+ * once per distinct (session, executionId); the integrator wires that to
+ * broadcast `{ type: "execution.started", … }` on /ws/events.
+ *
+ * Same streaming-safe design as PortDetector: a match touching the very end of
+ * the buffered text is held back (the id may still be growing in the next
+ * chunk) and finalized by `flush()`, which the integrator calls right after
+ * feeding a discrete, already-complete string (one tool.call field).
+ */
+/**
+ * Pure parser: every execution id announced in a chunk of CLI/tool output, in
+ * order (empty when the chunk announces none). This is the mutation-tested
+ * core — the {@link ExecutionDetector} class only adds streaming buffering and
+ * per-session dedupe on top of it.
+ */
+export declare function parseExecutionIds(text: string): string[];
+/** Where a detected run executes. Only `"prod"` is emitted today: the CLI's
+ *  `Started execution` line is the prod-run announcement; local runs are
+ *  rendered from their final result, not polled (see the design). */
+export type ExecutionTarget = "prod" | "local";
+export interface ExecutionDetectorDeps {
+    onExecution(harnessSessionId: string, executionId: string, target: ExecutionTarget): void;
+}
+/**
+ * Stateful, streaming-safe, and dedupes per (session, executionId) so a run id
+ * that reappears in output only ever fires `onExecution` once for the session's
+ * lifetime. `reset()` clears a session's state on exit so a reused session id
+ * starts clean.
+ */
+export declare class ExecutionDetector {
+    private readonly deps;
+    private readonly buffers;
+    private readonly seen;
+    constructor(deps: ExecutionDetectorDeps);
+    feed(chunk: string, harnessSessionId: string): void;
+    /**
+     * Finalizes whatever's held back for a session, immediately. Call this right
+     * after `feed()` whenever the fed text is a discrete, complete string (one
+     * tool.call field): without it, an id landing at the very end — the common
+     * shape "✓ Started execution exec_123" — would be held pending forever, since
+     * no "next chunk" is coming.
+     */
+    flush(harnessSessionId: string): void;
+    /** Drops buffered/dedupe state for a session — call on session exit so a
+     *  reused session id starts clean. */
+    reset(harnessSessionId: string): void;
+    private tryEmit;
+}
+//# sourceMappingURL=execution-detector.d.ts.map

package/dist/core/execution-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-detector.d.ts","sourceRoot":"","sources":["../../src/core/execution-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAgBH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAMxD;AAED;;qEAEqE;AACrE,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,OAAO,CAAC;AAE/C,MAAM,WAAW,qBAAqB;IACpC,WAAW,CACT,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,eAAe,GACtB,IAAI,CAAC;CACT;AAED;;;;;GAKG;AACH,qBAAa,iBAAiB;IAIhB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkC;gBAE1B,IAAI,EAAE,qBAAqB;IAExD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAsBnD;;;;;;OAMG;IACH,KAAK,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAUrC;0CACsC;IACtC,KAAK,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAKrC,OAAO,CAAC,OAAO;CAUhB"}

package/dist/core/execution-detector.js

@@ -0,0 +1,110 @@
+/**
+ * Execution detection — mirrors {@link PortDetector} (core/port-detector.ts).
+ *
+ * A run can start two ways in the harness, and this catches both:
+ *  1. The CLI prints `✓ Started execution <executionId>` (`sapiom agents run`).
+ *  2. The coding agent starts the run via the MCP run tool — the common path —
+ *     whose result carries the id as an `executionId` field
+ *     (`"executionId":"<id>"` / `executionId: <id>`).
+ * The detector is fed the SAME tool.call output PortDetector is (server/index.ts
+ * `onNormalizedEvent`, including the tool RESPONSE summary), so an MCP-triggered
+ * run is caught without changing how runs are triggered. It fires `onExecution`
+ * once per distinct (session, executionId); the integrator wires that to
+ * broadcast `{ type: "execution.started", … }` on /ws/events.
+ *
+ * Same streaming-safe design as PortDetector: a match touching the very end of
+ * the buffered text is held back (the id may still be growing in the next
+ * chunk) and finalized by `flush()`, which the integrator calls right after
+ * feeding a discrete, already-complete string (one tool.call field).
+ */
+/** Execution ids are the stable handles the executions API mints (e.g.
+ *  `exec_ab12…`). Id-safe characters only, so a trailing space, newline, or
+ *  ANSI reset ends the match rather than being captured into the id. */
+const EXECUTION_ID = String.raw `[A-Za-z0-9_-]+`;
+/** Two anchors, one capture group: the CLI's `Started execution <id>` line, or
+ *  the `executionId` field from the run tool's structured result (quote/colon/
+ *  space/equals between the key and the id). Both are start-time signals tied to
+ *  a real run, so a match always refers to a run the user is actually driving. */
+const EXECUTION_PATTERN_SOURCE = String.raw `(?:Started execution |executionId["'\s:=]+)(${EXECUTION_ID})`;
+/** Long enough to hold either anchor ("Started execution " / `executionId":"`)
+ *  split across a chunk boundary, plus a few id characters either side. */
+const TAIL_SAFETY = 48;
+/**
+ * Pure parser: every execution id announced in a chunk of CLI/tool output, in
+ * order (empty when the chunk announces none). This is the mutation-tested
+ * core — the {@link ExecutionDetector} class only adds streaming buffering and
+ * per-session dedupe on top of it.
+ */
+export function parseExecutionIds(text) {
+    const regex = new RegExp(EXECUTION_PATTERN_SOURCE, "g");
+    const ids = [];
+    let match;
+    while ((match = regex.exec(text)))
+        ids.push(match[1]);
+    return ids;
+}
+/**
+ * Stateful, streaming-safe, and dedupes per (session, executionId) so a run id
+ * that reappears in output only ever fires `onExecution` once for the session's
+ * lifetime. `reset()` clears a session's state on exit so a reused session id
+ * starts clean.
+ */
+export class ExecutionDetector {
+    constructor(deps) {
+        this.deps = deps;
+        this.buffers = new Map();
+        this.seen = new Map();
+    }
+    feed(chunk, harnessSessionId) {
+        const combined = (this.buffers.get(harnessSessionId) ?? "") + chunk;
+        const regex = new RegExp(EXECUTION_PATTERN_SOURCE, "g");
+        let match;
+        let pendingFrom = null;
+        while ((match = regex.exec(combined))) {
+            const end = match.index + match[0].length;
+            if (end === combined.length) {
+                // The id could still be growing (more chars due next chunk) — hold back.
+                pendingFrom = match.index;
+                break;
+            }
+            this.tryEmit(harnessSessionId, match[1]);
+        }
+        const retainFrom = pendingFrom ?? Math.max(0, combined.length - TAIL_SAFETY);
+        this.buffers.set(harnessSessionId, combined.slice(retainFrom));
+    }
+    /**
+     * Finalizes whatever's held back for a session, immediately. Call this right
+     * after `feed()` whenever the fed text is a discrete, complete string (one
+     * tool.call field): without it, an id landing at the very end — the common
+     * shape "✓ Started execution exec_123" — would be held pending forever, since
+     * no "next chunk" is coming.
+     */
+    flush(harnessSessionId) {
+        const pending = this.buffers.get(harnessSessionId);
+        if (!pending)
+            return;
+        // Re-parse the whole pending buffer (vs an inline loop) — same result, and
+        // tryEmit dedupes so a match already emitted by feed() is a harmless no-op.
+        for (const id of parseExecutionIds(pending))
+            this.tryEmit(harnessSessionId, id);
+        this.buffers.delete(harnessSessionId);
+    }
+    /** Drops buffered/dedupe state for a session — call on session exit so a
+     *  reused session id starts clean. */
+    reset(harnessSessionId) {
+        this.buffers.delete(harnessSessionId);
+        this.seen.delete(harnessSessionId);
+    }
+    tryEmit(harnessSessionId, executionId) {
+        let ids = this.seen.get(harnessSessionId);
+        if (!ids) {
+            ids = new Set();
+            this.seen.set(harnessSessionId, ids);
+        }
+        if (ids.has(executionId))
+            return;
+        ids.add(executionId);
+        this.deps.onExecution(harnessSessionId, executionId, "prod");
+    }
+}
+//# sourceMappingURL=execution-detector.js.map

package/dist/core/execution-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-detector.js","sourceRoot":"","sources":["../../src/core/execution-detector.ts"],"names":[],"mappings":"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"}

package/dist/core/inject/mcp-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-config.d.ts","sourceRoot":"","sources":["../../../src/core/inject/mcp-config.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,gBAAgB;IAC/B,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB;iFAC6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,gBAAgB,EAAE,MAAM,EACxB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,MAAM,CAAC,CA6BjB"}
+{"version":3,"file":"mcp-config.d.ts","sourceRoot":"","sources":["../../../src/core/inject/mcp-config.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,gBAAgB;IAC/B,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB;iFAC6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,gBAAgB,EAAE,MAAM,EACxB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,MAAM,CAAC,CAqCjB"}

package/dist/core/inject/mcp-config.js

@@ -25,7 +25,15 @@ export async function generateMcpConfig(harnessSessionId, options = {}) {
             },
             "sapiom-dev": {
                 command: "npx",
-                args: ["-y", "@sapiom/mcp"],
+                // Pin the dist-tag (`@latest`) rather than the bare name so npx always
+                // resolves the PUBLISHED package from the registry. A bare
+                // `@sapiom/mcp` resolves a LOCAL workspace copy whenever the harness
+                // runs from inside the sapiom-js monorepo (dogfooding/dev) — whose bin
+                // isn't linked, so the server fails to launch ("sapiom-mcp: command
+                // not found" → JSON-RPC -32000). A dist-tag spec forces registry
+                // resolution and is behaviourally identical to what a real user
+                // (outside the monorepo) already gets, so it's a pure robustness fix.
+                args: ["-y", "@sapiom/mcp@latest"],
                 ...(devEnv ? { env: devEnv } : {}),
             },
         },

package/dist/core/inject/mcp-config.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-config.js","sourceRoot":"","sources":["../../../src/core/inject/mcp-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAoBhD;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,gBAAwB,EACxB,UAA4B,EAAE;IAE9B,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,aAAa,IAAI,aAAa,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACtG,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAEzC,MAAM,iBAAiB,GAAG,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IAChF,MAAM,MAAM,GAAuC,iBAAiB;QAClE,CAAC,CAAC,EAAE,kBAAkB,EAAE,iBAAiB,EAAE;QAC3C,CAAC,CAAC,SAAS,CAAC;IAEd,MAAM,MAAM,GAAG;QACb,UAAU,EAAE;YACV,MAAM,EAAE;gBACN,IAAI,EAAE,MAAM;gBACZ,GAAG,EAAE,8BAA8B;gBACnC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACxE;YACD,YAAY,EAAE;gBACZ,OAAO,EAAE,KAAK;gBACd,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC;gBAC3B,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACnC;SACF;KACF,CAAC;IAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,iBAAiB,CAAC,CAAC;IACnD,yEAAyE;IACzE,oEAAoE;IACpE,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IACtF,OAAO,QAAQ,CAAC;AAClB,CAAC"}
+{"version":3,"file":"mcp-config.js","sourceRoot":"","sources":["../../../src/core/inject/mcp-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAoBhD;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,gBAAwB,EACxB,UAA4B,EAAE;IAE9B,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,aAAa,IAAI,aAAa,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACtG,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAEzC,MAAM,iBAAiB,GAAG,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IAChF,MAAM,MAAM,GAAuC,iBAAiB;QAClE,CAAC,CAAC,EAAE,kBAAkB,EAAE,iBAAiB,EAAE;QAC3C,CAAC,CAAC,SAAS,CAAC;IAEd,MAAM,MAAM,GAAG;QACb,UAAU,EAAE;YACV,MAAM,EAAE;gBACN,IAAI,EAAE,MAAM;gBACZ,GAAG,EAAE,8BAA8B;gBACnC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACxE;YACD,YAAY,EAAE;gBACZ,OAAO,EAAE,KAAK;gBACd,uEAAuE;gBACvE,2DAA2D;gBAC3D,qEAAqE;gBACrE,uEAAuE;gBACvE,oEAAoE;gBACpE,iEAAiE;gBACjE,gEAAgE;gBAChE,sEAAsE;gBACtE,IAAI,EAAE,CAAC,IAAI,EAAE,oBAAoB,CAAC;gBAClC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACnC;SACF;KACF,CAAC;IAEF,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,iBAAiB,CAAC,CAAC;IACnD,yEAAyE;IACzE,oEAAoE;IACpE,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IACtF,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/core/render-local-run.d.ts

@@ -0,0 +1,82 @@
+/**
+ * renderLocalRun — the pure mapper from an offline stub run's per-step traces
+ * ({@link LocalStepTrace}[], streamed as NDJSON by `POST /api/runs/local`) to
+ * the same {@link RunView} the canvas renders for prod runs. Its twin is
+ * {@link renderRunState} (prod / local-backend); both emit the identical
+ * cost-free {@link StepView} shape, so ONE inspector renders every run source.
+ *
+ * Pure and deterministic: no LLM, no I/O, no clock. Every field is derived from
+ * the traces (plus the caller-supplied execution id and terminal outcome), so
+ * the same function can map a partial trace mid-stream and the final trace at
+ * the end — only the input grows, never this mapping. It is a Stryker target;
+ * the tests are mutation-first.
+ *
+ * Honest absence, matching renderRunState and the SDK's "null is honest absence,
+ * never a fabricated value" contract:
+ *  - **No cost** — local runs are stubbed and free by construction; a StepView
+ *    from here never carries `costUsd` (so the inspector reads "local run ·
+ *    free", never "$0.00").
+ *  - **No latency** — a {@link LocalStepTrace} carries no timing (agent-core's
+ *    in-process dispatcher records none, and agent-core is consumed as-is), so
+ *    `latencyMs` is ABSENT rather than a fabricated `0`.
+ *  - **Output** is present only when the trace captured one (a step that threw,
+ *    or a `continue` with no value, carries none) — but ABSENCE is `undefined`
+ *    on the trace, and a genuine `null`/`false`/`0`/`""` output is a real value
+ *    that passes through.
+ *  - **Input** is always carried by a trace (every attempt ran on some input,
+ *    even `undefined`); it is surfaced whenever it isn't `undefined`.
+ *  - **Logs and errors** collapse to the same `logSlice`/`error` fields prod
+ *    uses, via the shared formatter.
+ *  - **Stub signal (WB15-2)** is RUN-LEVEL. A local run is stub-served by
+ *    construction, so the run carries `stubbed: true` (prod's renderRunState
+ *    never does) and the inspector marks each executed step with a "stubbed"
+ *    chip — agent-core records no per-CALL stub attribution, so that is the
+ *    honest granularity. The terminal summary's `unusedStubs` (a supplied key
+ *    that matched nothing) and `stubWarnings` (a wrong-shape value) pass through
+ *    only when NON-empty, so a clean run surfaces no notice at all.
+ */
+import type { LocalStepTrace, LocalRunOutcome } from "@sapiom/agent-core";
+import type { RunView, UnusedStubView } from "../shared/types.js";
+/**
+ * Options carrying the run-level facts a `LocalStepTrace[]` alone can't provide.
+ * Both are optional so the mapper can render a live, still-streaming trace (no
+ * terminal summary yet) exactly as it renders the final one.
+ */
+export interface RenderLocalRunOptions {
+    /**
+     * The execution id to stamp on the {@link RunView}. A local run has no
+     * server-issued id, so the caller (the SPA's run store) synthesizes and owns
+     * one; the mapper stays pure by taking it rather than minting time/randomness.
+     * Defaults to an empty string when the caller has none yet.
+     */
+    executionId?: string;
+    /**
+     * The run's terminal outcome from the NDJSON summary line, when it has
+     * arrived. Absent while the stream is still open — the mapper then reports the
+     * run as `running` (steps may still be coming). Passing it flips the run to
+     * its settled status.
+     */
+    outcome?: LocalRunOutcome;
+    /**
+     * Supplied stub keys that matched no capability call this run — from the
+     * terminal summary line. A no-op mock (typo'd path, wrong plural/singular)
+     * otherwise fails silently; surfacing it is the whole point of WB15-2. Only a
+     * NON-empty list reaches the {@link RunView} (honest absence), so pass it as-is
+     * from the summary and the mapper decides. Absent while the stream is open.
+     */
+    unusedStubs?: UnusedStubView[];
+    /**
+     * Warnings about stub values that matched a key but carried the wrong shape —
+     * from the terminal summary line. Same honest-absence handling as
+     * {@link RenderLocalRunOptions.unusedStubs}: an empty list is dropped.
+     */
+    stubWarnings?: string[];
+}
+/**
+ * Map an offline stub run's traces (plus the caller-owned execution id and, once
+ * known, terminal outcome) to the {@link RunView} the canvas renders. Order-
+ * preserving over `traces` (execution order); total — never throws, mirroring
+ * renderRunState — because the traces are already the decoded wire shape.
+ */
+export declare function renderLocalRun(traces: LocalStepTrace[], options?: RenderLocalRunOptions): RunView;
+//# sourceMappingURL=render-local-run.d.ts.map

package/dist/core/render-local-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-local-run.d.ts","sourceRoot":"","sources":["../../src/core/render-local-run.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1E,OAAO,KAAK,EACV,OAAO,EAIP,cAAc,EACf,MAAM,oBAAoB,CAAC;AAQ5B;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAoED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,cAAc,EAAE,EACxB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAsBT"}

package/dist/core/render-local-run.js

@@ -0,0 +1,105 @@
+// Reuse prod's exact log-buffer formatter so a step's `logSlice` is byte-
+// identical whether it came from a prod projection or a local trace — the
+// inspector can never disagree with itself about how a log renders. Imported
+// from the dependency-free module (NOT render-run-state) so this mapper carries
+// no `@sapiom/agent-core`/`node:fs` runtime dep into the browser bundle.
+import { toLogSlice } from "./render-log-slice.js";
+/**
+ * Fold a single step-attempt's status into a {@link StepStatus}. A local trace's
+ * status vocabulary is exactly `succeeded | threw` (see agent-core's
+ * LocalStubDispatcher). `succeeded` → `passed`; `threw` → `failed` (it did not
+ * pass — mirrors renderRunState's fold of `threw`). Anything unrecognized is
+ * `pending` (defensive; the union shouldn't produce it), NEVER silently
+ * `passed`.
+ */
+function toStepStatus(raw) {
+    if (raw === "succeeded")
+        return "passed";
+    if (raw === "threw")
+        return "failed";
+    return "pending";
+}
+/**
+ * Fold the run's terminal outcome into the four states the UI draws. A local run
+ * that `paused` is not yet done (the auto-resume loop or a human must advance
+ * it), so it reads as `running`, not a terminal state. An absent outcome (stream
+ * still open) is also `running`. `completed`/`failed` map straight through;
+ * there is no local "cancelled" outcome.
+ */
+function toRunStatus(outcome) {
+    if (outcome === "completed")
+        return "completed";
+    if (outcome === "failed")
+        return "failed";
+    // "paused", "running", or absent (still streaming) — not terminal.
+    return "running";
+}
+/**
+ * Map one trace line to its {@link StepView}. Optional fields are assigned only
+ * when they carry a real value, so honest absence survives into the JSON the
+ * inspector reads (a missing field renders nothing rather than a fabricated
+ * zero/empty payload).
+ */
+function toStepView(trace) {
+    const view = {
+        // Local traces have no OTel span id; the (step, attempt) pair is the stable,
+        // collision-free key across a run's attempts of the same step.
+        id: `${trace.step}-${trace.attempt}`,
+        name: trace.step,
+        status: toStepStatus(trace.status),
+    };
+    // No costUsd, no latencyMs — a local run is free and untimed (see the file
+    // header). Their honest absence is the whole point of the local target.
+    if (trace.input !== undefined)
+        view.input = trace.input;
+    if (trace.output !== undefined)
+        view.output = trace.output;
+    if (trace.error?.message)
+        view.error = trace.error.message;
+    const logSlice = toLogSlice(trace.logs);
+    if (logSlice !== undefined)
+        view.logSlice = logSlice;
+    // Per-step capability calls from the stub client. Honest absence: only a
+    // non-empty list reaches the view (an empty list means no calls were made —
+    // but absence on the trace means the sink was never wired, so we leave it
+    // absent too). The StubCallRecord shape maps directly onto StepCall.
+    if (trace.calls && trace.calls.length > 0) {
+        view.calls = trace.calls.map((c) => ({
+            capability: c.capability,
+            stubUsed: c.stubUsed,
+            args: c.args,
+            result: c.result,
+        }));
+    }
+    return view;
+}
+/**
+ * Map an offline stub run's traces (plus the caller-owned execution id and, once
+ * known, terminal outcome) to the {@link RunView} the canvas renders. Order-
+ * preserving over `traces` (execution order); total — never throws, mirroring
+ * renderRunState — because the traces are already the decoded wire shape.
+ */
+export function renderLocalRun(traces, options = {}) {
+    const view = {
+        executionId: options.executionId ?? "",
+        status: toRunStatus(options.outcome),
+        steps: traces.map(toStepView),
+        // A local run is stub-served by construction (every ctx.sapiom.* call
+        // resolves from a stub, never the network) — so the run itself is `stubbed`,
+        // and the inspector marks each executed step with the chip. This is the
+        // honest per-run truth: agent-core records no per-CALL stub attribution, so
+        // there is nothing finer to claim. renderRunState (prod) never sets this.
+        stubbed: true,
+    };
+    // Honest absence: only a NON-empty signal reaches the view, so the read-only
+    // notice renders nothing when the run had no stub-hygiene problems. A supplied
+    // empty array is indistinguishable from "no problems" and must not surface.
+    if (options.unusedStubs && options.unusedStubs.length > 0) {
+        view.unusedStubs = options.unusedStubs;
+    }
+    if (options.stubWarnings && options.stubWarnings.length > 0) {
+        view.stubWarnings = options.stubWarnings;
+    }
+    return view;
+}
+//# sourceMappingURL=render-local-run.js.map

package/dist/core/render-local-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-local-run.js","sourceRoot":"","sources":["../../src/core/render-local-run.ts"],"names":[],"mappings":"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"}

package/dist/core/render-log-slice.d.ts

@@ -0,0 +1,30 @@
+/**
+ * render-log-slice — the shared, dependency-free formatter for a step's executor
+ * log buffer. Both run mappers use it so a step's `logSlice` is byte-identical
+ * whether it came from a prod {@link import("./render-run-state.js").renderRunState}
+ * projection or a local {@link import("./render-local-run.js").renderLocalRun}
+ * trace — the inspector can never disagree with itself about how a log renders.
+ *
+ * Kept in its OWN module (rather than in render-run-state.ts) precisely because
+ * it has NO `@sapiom/agent-core` dependency: render-run-state pulls in agent-core
+ * runtime helpers (e.g. `isExecutionTerminal`) that reach for `node:fs`, which
+ * must never enter the browser bundle. The local-run mapper is imported by the
+ * SPA, so it depends on THIS pure module instead — no Node built-ins ride along.
+ *
+ * Pure and deterministic: no I/O, no clock. Safe in both Node and the browser.
+ */
+/**
+ * Cap on the characters of a step's executor log buffer surfaced in `logSlice`.
+ * The TAIL is kept (most recent lines) because failures surface at the end of a
+ * log. This is a payload guard on the poll/stream response; the debug-macro
+ * context extractor does the final, smaller trim for prompt injection.
+ */
+export declare const LOG_SLICE_MAX = 4000;
+/** One executor log entry → a compact line. Accepts the `{ ts, level, msg }`
+ *  wire shape (or `message`), a bare string, or anything else (stringified).
+ *  A local trace's `{ level, msg }` entry is a subset of this same shape. */
+export declare function formatLogEntry(entry: unknown): string;
+/** Format the executor log buffer into a trimmed, tail-preserving slice, or
+ *  `undefined` when there are no usable logs. */
+export declare function toLogSlice(logs: unknown): string | undefined;
+//# sourceMappingURL=render-log-slice.d.ts.map

package/dist/core/render-log-slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-log-slice.d.ts","sourceRoot":"","sources":["../../src/core/render-log-slice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC;;6EAE6E;AAC7E,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAgBrD;AAED;iDACiD;AACjD,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAO5D"}

package/dist/core/render-log-slice.js

@@ -0,0 +1,49 @@
+/**
+ * render-log-slice — the shared, dependency-free formatter for a step's executor
+ * log buffer. Both run mappers use it so a step's `logSlice` is byte-identical
+ * whether it came from a prod {@link import("./render-run-state.js").renderRunState}
+ * projection or a local {@link import("./render-local-run.js").renderLocalRun}
+ * trace — the inspector can never disagree with itself about how a log renders.
+ *
+ * Kept in its OWN module (rather than in render-run-state.ts) precisely because
+ * it has NO `@sapiom/agent-core` dependency: render-run-state pulls in agent-core
+ * runtime helpers (e.g. `isExecutionTerminal`) that reach for `node:fs`, which
+ * must never enter the browser bundle. The local-run mapper is imported by the
+ * SPA, so it depends on THIS pure module instead — no Node built-ins ride along.
+ *
+ * Pure and deterministic: no I/O, no clock. Safe in both Node and the browser.
+ */
+/**
+ * Cap on the characters of a step's executor log buffer surfaced in `logSlice`.
+ * The TAIL is kept (most recent lines) because failures surface at the end of a
+ * log. This is a payload guard on the poll/stream response; the debug-macro
+ * context extractor does the final, smaller trim for prompt injection.
+ */
+export const LOG_SLICE_MAX = 4000;
+/** One executor log entry → a compact line. Accepts the `{ ts, level, msg }`
+ *  wire shape (or `message`), a bare string, or anything else (stringified).
+ *  A local trace's `{ level, msg }` entry is a subset of this same shape. */
+export function formatLogEntry(entry) {
+    if (typeof entry === "string")
+        return entry;
+    if (entry !== null && typeof entry === "object") {
+        const e = entry;
+        const parts = [e.ts, e.level, e.msg ?? e.message].filter((p) => typeof p === "string" || typeof p === "number");
+        if (parts.length > 0)
+            return parts.map(String).join(" ");
+    }
+    return String(entry);
+}
+/** Format the executor log buffer into a trimmed, tail-preserving slice, or
+ *  `undefined` when there are no usable logs. */
+export function toLogSlice(logs) {
+    if (!Array.isArray(logs) || logs.length === 0)
+        return undefined;
+    const text = logs.map(formatLogEntry).join("\n").trim();
+    if (text === "")
+        return undefined;
+    return text.length > LOG_SLICE_MAX
+        ? text.slice(text.length - LOG_SLICE_MAX)
+        : text;
+}
+//# sourceMappingURL=render-log-slice.js.map

package/dist/core/render-log-slice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-log-slice.js","sourceRoot":"","sources":["../../src/core/render-log-slice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,CAAC;AAElC;;6EAE6E;AAC7E,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC5C,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChD,MAAM,CAAC,GAAG,KAKT,CAAC;QACF,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CACtD,CAAC,CAAC,EAAwB,EAAE,CAC1B,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,CACjD,CAAC;QACF,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC;AAED;iDACiD;AACjD,MAAM,UAAU,UAAU,CAAC,IAAa;IACtC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAChE,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;IACxD,IAAI,IAAI,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IAClC,OAAO,IAAI,CAAC,MAAM,GAAG,aAAa;QAChC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC;QACzC,CAAC,CAAC,IAAI,CAAC;AACX,CAAC"}

package/dist/core/render-run-state.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutionProjection } from "@sapiom/agent-core";
+import type { RunView } from "../shared/types.js";
+/**
+ * Map a decoded {@link ExecutionProjection} to the {@link RunView} the canvas
+ * renders. Order-preserving over `steps`; total (never throws) because the
+ * projection is already the decoded, degradation-tolerant shape.
+ */
+export declare function renderRunState(decoded: ExecutionProjection): RunView;
+//# sourceMappingURL=render-run-state.d.ts.map

package/dist/core/render-run-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-run-state.d.ts","sourceRoot":"","sources":["../../src/core/render-run-state.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EAAE,OAAO,EAAwB,MAAM,oBAAoB,CAAC;AA0FxE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAMpE"}