@op0ai/sdk 0.3.1 → 0.4.1

package/dist/session.js

@@ -1,88 +1,2 @@
-// session.ts — the Session seam (ADR-30): coding-ops over harness-agnostic LIVE sessions.
-//
-// Parallel to the Source seam (source.ts = static repos; this = live coding sessions). Three modes:
-//   owned    — op0 creates the session in our runtime (WfP/Sandbox): full control + full intercept.
-//   attached — op0 drives an EXISTING session via the session-connector (local daemon, ADR-4d): partial.
-//   streamed — op0 observes + intercepts a session it does NOT run, via the lapdog/trajectory pattern:
-//              HOOKS = observe (fail-open, fire-and-forget) · model-PROXY = in-path = INTERCEPTABLE.
-//              This is how we "audit work we're not controlling" AND keep a governance gate (deepsec)
-//              on the proxy path even for sessions we didn't launch.
-//
-// Harness-agnostic (Claude Code / Codex / Cursor / Gemini / opencode / Copilot / Factory / Pi): MINE the
-// OSS reference `datadog-labs/trajectory` (per-client hook/proxy/watcher/backfill instrumentation) rather
-// than hand-rolling — the "check for an existing OSS framework first" lesson. *Verify its license before
-// adapting code; otherwise inspiration-only and build our thin capture on the same vectors.* Observability
-// is commoditized by Datadog (lapdog/trajectory) — our moat is the ACT half: govern · intercept · turn the
-// session into a governed onloop run · the flywheel. evlog ingests these traces as just another Source.
-//
-// Pure TS, zero deps (Node + Worker). Reuses the @op0-ai/cord guards so a streamed session yields the SAME
-// evlog WideEvents + tamper-evident audit as an owned cord run.
-import { makeAuditChain, verifyChain } from "./guards.js";
-import { newId } from "./hash.js";
-export const DEFAULT_RULES = [
-    { id: "force-push", match: (e) => e.kind === "tool_call" && /\bgit\s+push\b.*--force(?!-with-lease)/.test(e.name), decision: "deny", why: "force-push without --force-with-lease" },
-    { id: "rm-rf", match: (e) => e.kind === "tool_call" && /\brm\s+-rf\b/.test(e.name), decision: "approve", why: "destructive delete — needs human approval" },
-    { id: "secret-exfil", match: (e) => e.kind === "tool_call" && /(curl|wget)\b.*(\.env|secret|token|key)/i.test(e.name), decision: "approve", why: "possible secret exfiltration" },
-];
-// enforceable ONLY when the event is actionable: owned/attached (we drive it) or streamed-via-PROXY (in-path).
-// streamed-via-hook is observe-only (fail-open) → we can flag/audit but not block.
-const canEnforce = (mode, vector) => mode === "owned" || mode === "attached" || (mode === "streamed" && vector === "proxy");
-export const intercept = (stream, rules = DEFAULT_RULES) => {
-    const out = [];
-    for (const e of stream.events) {
-        for (const r of rules) {
-            if (r.match(e))
-                out.push({ event: e, rule: r, decision: r.decision, enforceable: canEnforce(stream.mode, e.vector) });
-        }
-    }
-    return out;
-};
-export const ingestSession = (stream, rules = DEFAULT_RULES) => {
-    const chain = makeAuditChain();
-    chain.append({ actor: "deepsec", action: "session.capture", scopeId: stream.mode, payload: { harness: stream.harness, mode: stream.mode } });
-    const events = stream.events.map((e) => ({
-        ts: e.ts, runId: stream.runId, tenantId: "op0", cordId: "@op0/coding-ops",
-        kind: e.kind === "tool_call" || e.kind === "tool_result" ? "tool" : e.kind === "model" ? "model" : "step",
-        name: e.name, durationMs: 0, ok: true,
-        attrs: { vector: e.vector, ...(e.attrs ?? {}) },
-    }));
-    const interceptions = intercept(stream, rules);
-    for (const i of interceptions) {
-        chain.append({
-            actor: "deepsec",
-            action: i.enforceable ? `intercept.${i.decision}` : "intercept.flag",
-            scopeId: stream.mode,
-            payload: { rule: i.rule.id, why: i.rule.why, event: i.event.name, enforceable: i.enforceable },
-        });
-    }
-    chain.append({ actor: "deepsec", action: "session.settle", scopeId: stream.mode, payload: { runId: stream.runId, events: events.length, interceptions: interceptions.length } });
-    return { runId: stream.runId, harness: stream.harness, mode: stream.mode, events, audit: chain.entries, interceptions };
-};
-// --- streamed adapter: parse a lapdog/trajectory-style JSONL capture into a SessionStream ---
-// (lapdog hooks POST one JSON per event; trajectory writes JSONL timelines. This is a minimal normalized
-//  subset for the spike; the real adapter maps each harness's hook/proxy schema — mine trajectory's.)
-export const fromTrajectoryJsonl = (jsonl, harness, mode = "streamed") => {
-    const events = [];
-    for (const line of jsonl.split("\n")) {
-        const t = line.trim();
-        if (!t)
-            continue;
-        let o;
-        try {
-            o = JSON.parse(t);
-        }
-        catch {
-            continue;
-        }
-        events.push({
-            ts: o.ts ?? new Date().toISOString(),
-            kind: o.kind ?? "lifecycle",
-            name: o.name ?? o.tool ?? o.event ?? "event",
-            vector: o.vector ?? "hook",
-            attrs: o.attrs, tokensIn: o.tokensIn, tokensOut: o.tokensOut, costUsd: o.costUsd,
-        });
-    }
-    return { mode, harness, runId: newId(), events };
-};
-export { verifyChain };
-//# sourceMappingURL=session.js.map
+var a=e=>{let n=2166136261;for(let o=0;o<e.length;o++)n^=e.charCodeAt(o),n=Math.imul(n,16777619);return(n>>>0).toString(16).padStart(8,"0")};var p=()=>Date.now().toString(36)+"-"+Math.random().toString(36).slice(2,8);var l=e=>a([e.seq,e.ts,e.actor,e.action,e.scopeId,e.payloadHash,e.prevHash].join("|")),u=()=>{let e=[];return{entries:e,append({actor:n,action:o,scopeId:r,payload:s}){let t=e.length,i=new Date().toISOString(),g=t===0?"GENESIS":e[t-1]?.hash??"GENESIS",y=a(JSON.stringify(s??null)),c={seq:t,ts:i,actor:n,action:o,scopeId:r,payloadHash:y,prevHash:g},d={...c,hash:l(c)};return e.push(d),d}}},f=e=>{for(let n=0;n<e.length;n++){let o=e[n];if(!o)return!1;let r=n===0?"GENESIS":e[n-1]?.hash??"GENESIS";if(o.prevHash!==r)return!1;let{hash:s,...t}=o;if(s!==l(t))return!1}return!0};var h=[{id:"force-push",match:e=>e.kind==="tool_call"&&/\bgit\s+push\b.*--force(?!-with-lease)/.test(e.name),decision:"deny",why:"force-push without --force-with-lease"},{id:"rm-rf",match:e=>e.kind==="tool_call"&&/\brm\s+-rf\b/.test(e.name),decision:"approve",why:"destructive delete \u2014 needs human approval"},{id:"secret-exfil",match:e=>e.kind==="tool_call"&&/(curl|wget)\b.*(\.env|secret|token|key)/i.test(e.name),decision:"approve",why:"possible secret exfiltration"}],m=(e,n)=>e==="owned"||e==="attached"||e==="streamed"&&n==="proxy",v=(e,n=h)=>{let o=[];for(let r of e.events)for(let s of n)s.match(r)&&o.push({event:r,rule:s,decision:s.decision,enforceable:m(e.mode,r.vector)});return o},I=(e,n=h)=>{let o=u();o.append({actor:"deepsec",action:"session.capture",scopeId:e.mode,payload:{harness:e.harness,mode:e.mode}});let r=e.events.map(t=>({ts:t.ts,runId:e.runId,tenantId:"op0",cordId:"@op0/coding-ops",kind:t.kind==="tool_call"||t.kind==="tool_result"?"tool":t.kind==="model"?"model":"step",name:t.name,durationMs:0,ok:!0,attrs:{vector:t.vector,...t.attrs??{}}})),s=v(e,n);for(let t of s)o.append({actor:"deepsec",action:t.enforceable?`intercept.${t.decision}`:"intercept.flag",scopeId:e.mode,payload:{rule:t.rule.id,why:t.rule.why,event:t.event.name,enforceable:t.enforceable}});return o.append({actor:"deepsec",action:"session.settle",scopeId:e.mode,payload:{runId:e.runId,events:r.length,interceptions:s.length}}),{runId:e.runId,harness:e.harness,mode:e.mode,events:r,audit:o.entries,interceptions:s}},b=(e,n,o="streamed")=>{let r=[];for(let s of e.split(`
+`)){let t=s.trim();if(!t)continue;let i;try{i=JSON.parse(t)}catch{continue}r.push({ts:i.ts??new Date().toISOString(),kind:i.kind??"lifecycle",name:i.name??i.tool??i.event??"event",vector:i.vector??"hook",attrs:i.attrs,tokensIn:i.tokensIn,tokensOut:i.tokensOut,costUsd:i.costUsd})}return{mode:o,harness:n,runId:p(),events:r}};export{h as DEFAULT_RULES,b as fromTrajectoryJsonl,I as ingestSession,v as intercept,f as verifyChain};

package/dist/{agent.d.ts → types/agent.d.ts}

@@ -17,7 +17,6 @@ export declare const fakeInference: (script: Array<{
 /**
  * portsAsTools — expose selected resource ports to the agent as callable tools. THIS is governed-tools = ports:
  * the agent can only act through capabilities the cord declared + the host bound. `onTool` lets the cord audit
- * every call (one wide-event per action). ponytail: only the ports you pass become tools — nothing else.
+ * every call (one wide-event per action). Only the ports you pass become tools — nothing else.
  */
 export declare const portsAsTools: (res: Resources, onTool?: (name: string, args: Record<string, unknown>) => void) => ToolSpec[];
-//# sourceMappingURL=agent.d.ts.map

package/dist/{agui.d.ts → types/agui.d.ts}

@@ -84,4 +84,3 @@ export interface Emitter {
     errored(error: string): void;
 }
 export declare function createEmitter(runId: string, sink: AgentEventSink): Emitter;
-//# sourceMappingURL=agui.d.ts.map

package/dist/{config.d.ts → types/config.d.ts}

@@ -75,4 +75,3 @@ export declare function toolsToOpenAI(tools: readonly Tool[] | ToolSet): Array<{
         parameters: unknown;
     };
 }>;
-//# sourceMappingURL=config.d.ts.map

package/dist/{contract.d.ts → types/contract.d.ts}

@@ -39,4 +39,3 @@ export declare function accumToolCalls(acc: Record<number, ToolCallAccum>, delta
         arguments?: string;
     };
 }>): Record<number, ToolCallAccum>;
-//# sourceMappingURL=contract.d.ts.map

package/dist/{data.d.ts → types/data.d.ts}

@@ -165,4 +165,3 @@ export type DataResponse = {
  */
 export declare function dataPlaneRpc(engine: DataEngine, req: DataRequest, connId?: string): Promise<DataResponse>;
 export {};
-//# sourceMappingURL=data.d.ts.map

package/dist/{define.d.ts → types/define.d.ts}

@@ -27,4 +27,3 @@ export interface AgentRpcContext {
  * This is the server half of the thin typed client (client.tsx). RPC edits commit immediately (no debounce).
  */
 export declare function cordRpc(request: Request, ctx: AgentRpcContext): Promise<Response>;
-//# sourceMappingURL=define.d.ts.map

package/dist/{distill.d.ts → types/distill.d.ts}

@@ -65,4 +65,3 @@ export interface SkillStore {
 export declare function storeSkillSink(store: SkillStore, opts?: {
     prefix?: string;
 }): SkillSink;
-//# sourceMappingURL=distill.d.ts.map

package/dist/{events.d.ts → types/events.d.ts}

@@ -36,4 +36,3 @@ export declare function askLedgerEvent(fields: Omit<AskLedgerEvent, "kind" | "at
 export declare function isAskLedgerEvent(r: unknown): r is AskLedgerEvent;
 /** The tenant a cord addr belongs to under the LOCKED `<team>--<name>` scheme; null = solo/untenanted. */
 export declare const tenantOfAgent: (cord: string) => string | null;
-//# sourceMappingURL=events.d.ts.map

package/dist/{evlog.d.ts → types/evlog.d.ts}

@@ -68,4 +68,3 @@ export declare function agentObserver(opts: {
     host: SqlHost;
     analytics?: AnalyticsSink;
 }): AgentObserver;
-//# sourceMappingURL=evlog.d.ts.map

package/dist/types/guards.d.ts

@@ -0,0 +1,60 @@
+export type GuardEvent = {
+    cord: string;
+    tool?: string;
+    scope?: string;
+    input: unknown;
+};
+export type WideEvent = {
+    ts: string;
+    runId: string;
+    tenantId: string;
+    cordId: string;
+    kind: "turn" | "step" | "model" | "tool" | "eval";
+    name: string;
+    durationMs: number;
+    ok: boolean;
+    scope?: string;
+    error?: {
+        code: string;
+        why: string;
+    };
+    attrs?: Record<string, unknown>;
+};
+export type AuditEntry = {
+    seq: number;
+    ts: string;
+    actor: string;
+    action: string;
+    scopeId: string;
+    payloadHash: string;
+    prevHash: string;
+    hash: string;
+};
+export type Guard = {
+    name: string;
+    /** Gate hook: deny by throwing (deepsec scope check), or instrument by side-effect. */
+    onCall?: (ev: GuardEvent) => void | Promise<void>;
+    /** Output transform applied before persist/export (deepsec redaction). */
+    redact?: <T>(value: T) => T;
+    /** Wide-event sink (deepeval instrumentation). */
+    onEvent?: (e: WideEvent) => void;
+};
+export type AuditChain = {
+    entries: AuditEntry[];
+    append(e: {
+        actor: string;
+        action: string;
+        scopeId: string;
+        payload: unknown;
+    }): AuditEntry;
+};
+export declare const makeAuditChain: () => AuditChain;
+/** Re-derive every hash; any insert/edit/delete breaks the chain → returns false. (The S7 red test.) */
+export declare const verifyChain: (entries: AuditEntry[]) => boolean;
+/** deepsec — scope gate + redaction (ADR-10). The runtime also drives an audit chain tagged actor="deepsec". */
+export declare const deepsec: (opts?: {
+    allow?: string[];
+    secrets?: RegExp[];
+}) => Guard;
+/** deepeval — instruments every run (ADR-24). Collects wide-events; prod forwards to evlog (OTLP + PostHog). */
+export declare const deepeval: (sink?: WideEvent[]) => Guard;

package/dist/types/hash.d.ts

@@ -0,0 +1,5 @@
+export declare const hashHex: (s: string) => string;
+/** A url-safe slug for vault keys (target → reports/<slug>/<runId>.json). */
+export declare const slug: (s: string) => string;
+/** A short, sortable-ish run id (timestamp + entropy). No node: deps. */
+export declare const newId: () => string;

package/dist/types/index.d.ts

@@ -0,0 +1,120 @@
+export * from "./hash.ts";
+export * from "./vault.ts";
+export * from "./guards.ts";
+export * from "./platform.ts";
+export * from "./agent.ts";
+export * from "./source.ts";
+export * from "./agui.ts";
+export * from "./tool.ts";
+export * from "./config.ts";
+export * from "./define.ts";
+export * from "./contract.ts";
+export * from "./evlog.ts";
+export * from "./events.ts";
+export * from "./usectx.ts";
+export * from "./distill.ts";
+export * from "./data.ts";
+import type { Vault } from "./vault.ts";
+import type { Resources, ResourceNeed } from "./platform.ts";
+import { type Guard, type WideEvent, type AuditEntry } from "./guards.ts";
+/** A sub-cord: an encapsulated unit composed into a parent. `any` generics (not `unknown`) so a typed
+ *  `subcords` record — { scan: Subagent<string,Facts>, score: Subagent<Facts,EvalResult>, ... } — is assignable
+ *  to Record<string, Subagent> (Subagent<X,Y> is NOT assignable to Subagent<unknown,unknown> — invariant `run`
+ *  param — but IS assignable to Subagent<any,any>). Same heterogeneous-registry seam as data.ts's AnyFn. */
+export type Subagent<I = any, O = any> = {
+    id: string;
+    mount: "local" | "registry";
+    run: (input: I) => Promise<O>;
+};
+/** Mount an OWNED sub-cord in-process (deterministic trunk). */
+export declare function use<I, O>(sc: {
+    id: string;
+    run: (input: I) => Promise<O>;
+}): Subagent<I, O>;
+/** Mount a THIRD-PARTY/registry cord over MCP (the trust boundary; an executor toolkit). */
+export declare function useRemote<I, O>(sc: {
+    id: string;
+    call: (input: I) => Promise<O>;
+}): Subagent<I, O>;
+export type Expose = {
+    codemode?: boolean;
+    mcp?: string;
+    cli?: boolean;
+    openapi?: boolean;
+};
+export type AgentDef<Input, Output> = {
+    id: string;
+    kind?: "agent-ful" | "agent-less";
+    inference?: "managed" | "byo";
+    /** The scope this cord's run requests — checked by deepsec against its allow-list (H4). */
+    scope?: string;
+    expose?: Expose;
+    guards?: Guard[];
+    subcords?: Record<string, Subagent>;
+    /** Durable resources this cord requires; the host MUST bind them or the run fails fast (validated post-gate). */
+    needs?: ResourceNeed[];
+    /** The deterministic trunk: compose sub-cords (ctx) + use the host-bound resources (res). */
+    run: (input: Input, ctx: Record<string, (input: any) => Promise<any>>, res: Resources) => Promise<Output>;
+};
+export type RunBudget = {
+    cap: number;
+    used: number;
+    depth: number;
+    maxDepth: number;
+};
+export type RunOpts = {
+    tenantId?: string;
+    scope?: string;
+    vault?: Vault;
+    resources?: Resources;
+    budget?: Partial<Pick<RunBudget, "cap" | "maxDepth">>;
+    onEvent?: (e: WideEvent) => void;
+};
+export type RunResult<O> = {
+    output: O;
+    runId: string;
+    artifact?: {
+        key: string;
+        version: string;
+        hash: string;
+    };
+    audit: AuditEntry[];
+    events: WideEvent[];
+    budget: RunBudget;
+};
+export type AgentManifest = {
+    id: string;
+    version: string;
+    kind: "agent-ful" | "agent-less";
+    inference: "managed" | "byo";
+    scope?: string;
+    expose: Expose;
+    subcords: string[];
+    guards: string[];
+    needs: ResourceNeed[];
+};
+export type Agent<Input, Output> = {
+    id: string;
+    expose: Expose;
+    manifest: AgentManifest;
+    run: (input: Input, opts?: RunOpts) => Promise<Output>;
+    runFull: (input: Input, opts?: RunOpts) => Promise<RunResult<Output>>;
+};
+export declare function defineAgent<Input, Output>(def: AgentDef<Input, Output>): Agent<Input, Output>;
+/** /.well-known/op0.json (ADR-18) generated from the cord's `expose`. Host is filled at deploy. */
+export declare const wellKnown: (m: AgentManifest, host?: string) => {
+    auth?: {
+        type: string;
+        scopes: string[];
+    };
+    skills: string;
+    cli?: string;
+    openapi?: string;
+    mcp: string[];
+    docs: string;
+};
+/** Content-address the manifest for skillkit publish/fork lineage (signed → forkOf{atCommit} later, ADR-22). */
+export declare const signManifest: (m: AgentManifest) => {
+    manifest: AgentManifest;
+    hash: string;
+};

package/dist/{platform.d.ts → types/platform.d.ts}

@@ -94,4 +94,3 @@ export interface RunSpec {
     /** Who checks the result: a verifier cord/tool name, or "none" (explicitly unverified). */
     verifier?: string;
 }
-//# sourceMappingURL=platform.d.ts.map

package/dist/types/session.d.ts

@@ -0,0 +1,46 @@
+import { verifyChain, type WideEvent, type AuditEntry } from "./guards.ts";
+export type SessionMode = "owned" | "attached" | "streamed";
+export type CaptureVector = "hook" | "proxy" | "watcher" | "backfill";
+/** A normalized coding-session event (mirrors lapdog/trajectory capture). */
+export type SessionEvent = {
+    ts: string;
+    kind: "lifecycle" | "prompt" | "model" | "tool_call" | "tool_result" | "permission";
+    name: string;
+    vector: CaptureVector;
+    attrs?: Record<string, unknown>;
+    tokensIn?: number;
+    tokensOut?: number;
+    costUsd?: number;
+};
+export type SessionStream = {
+    mode: SessionMode;
+    harness: string;
+    runId: string;
+    events: SessionEvent[];
+};
+export type Decision = "allow" | "deny" | "approve";
+export type Rule = {
+    id: string;
+    match: (e: SessionEvent) => boolean;
+    decision: Decision;
+    why: string;
+};
+export declare const DEFAULT_RULES: Rule[];
+export type Interception = {
+    event: SessionEvent;
+    rule: Rule;
+    decision: Decision;
+    enforceable: boolean;
+};
+export declare const intercept: (stream: SessionStream, rules?: Rule[]) => Interception[];
+export type SessionTrace = {
+    runId: string;
+    harness: string;
+    mode: SessionMode;
+    events: WideEvent[];
+    audit: AuditEntry[];
+    interceptions: Interception[];
+};
+export declare const ingestSession: (stream: SessionStream, rules?: Rule[]) => SessionTrace;
+export declare const fromTrajectoryJsonl: (jsonl: string, harness: string, mode?: SessionMode) => SessionStream;
+export { verifyChain };

package/dist/{source.d.ts → types/source.d.ts}

@@ -62,4 +62,3 @@ export declare function githubCommitter(config: {
     base?: string;
     fetch?: typeof fetch;
 }): Committer;
-//# sourceMappingURL=source.d.ts.map

package/dist/{tool.d.ts → types/tool.d.ts}

@@ -40,4 +40,3 @@ export interface ToolManifestEntry {
     readonly description: string;
 }
 export declare function toolManifest<Env>(tools: ToolSet<Env>): ToolManifestEntry[];
-//# sourceMappingURL=tool.d.ts.map

package/dist/{usectx.d.ts → types/usectx.d.ts}

@@ -90,4 +90,3 @@ export interface UsectxConfig {
  * resulting FileSet with in-band redaction + audit. This is the one acquisition primitive a cord uses.
  */
 export declare function usectx(config?: UsectxConfig): Acquire;
-//# sourceMappingURL=usectx.d.ts.map

package/dist/types/vault.d.ts

@@ -0,0 +1,20 @@
+export interface Vault {
+    /** Write a deliverable; returns its key + version + content hash (content-addressing → fork lineage). */
+    put(key: string, body: string, meta?: Record<string, unknown>): Promise<{
+        key: string;
+        version: string;
+        hash: string;
+    }>;
+    /** Read a deliverable back (latest version), or null. */
+    get(key: string): Promise<string | null>;
+    /** List keys under a prefix. */
+    list(prefix?: string): Promise<string[]>;
+}
+/** In-memory Vault — the verify/Node default and the H3 red-test substrate. Versions on repeated keys. */
+export declare const memVault: () => Vault & {
+    store: Map<string, {
+        body: string;
+        version: number;
+        meta?: unknown;
+    }>;
+};

package/dist/vault.d.ts

@@ -1,21 +1 @@
-export interface Vault {
-    /** Write a deliverable; returns its key + version + content hash (content-addressing → fork lineage). */
-    put(key: string, body: string, meta?: Record<string, unknown>): Promise<{
-        key: string;
-        version: string;
-        hash: string;
-    }>;
-    /** Read a deliverable back (latest version), or null. */
-    get(key: string): Promise<string | null>;
-    /** List keys under a prefix. */
-    list(prefix?: string): Promise<string[]>;
-}
-/** In-memory Vault — the verify/Node default and the H3 red-test substrate. Versions on repeated keys. */
-export declare const memVault: () => Vault & {
-    store: Map<string, {
-        body: string;
-        version: number;
-        meta?: unknown;
-    }>;
-};
-//# sourceMappingURL=vault.d.ts.map
+export * from "./types/vault.js";

package/dist/vault.js

@@ -1,25 +1 @@
-// vault.ts — the Vault seam (ADR-8). A cord's deliverables are persisted as versioned artifacts; the cord
-// core depends ONLY on this interface, so the SAME run logic writes to an in-memory store (Node/verify), an
-// R2 bucket (the Worker — see worker/src/vault.ts), or Cloudflare Artifacts (the versioned git target,
-// deploy-time). H3 = "every assess leaves a versioned deliverable" — the runtime calls vault.put() once the
-// deepsec gate has redacted the output.
-import { hashHex } from "./hash.js";
-/** In-memory Vault — the verify/Node default and the H3 red-test substrate. Versions on repeated keys. */
-export const memVault = () => {
-    const store = new Map();
-    return {
-        store,
-        async put(key, body, meta) {
-            const version = (store.get(key)?.version ?? 0) + 1;
-            store.set(key, { body, version, meta });
-            return { key, version: String(version), hash: hashHex(body) };
-        },
-        async get(key) {
-            return store.get(key)?.body ?? null;
-        },
-        async list(prefix = "") {
-            return [...store.keys()].filter((k) => k.startsWith(prefix));
-        },
-    };
-};
-//# sourceMappingURL=vault.js.map
+var s=r=>{let t=2166136261;for(let n=0;n<r.length;n++)t^=r.charCodeAt(n),t=Math.imul(t,16777619);return(t>>>0).toString(16).padStart(8,"0")};var a=()=>{let r=new Map;return{store:r,async put(t,n,i){let e=(r.get(t)?.version??0)+1;return r.set(t,{body:n,version:e,meta:i}),{key:t,version:String(e),hash:s(n)}},async get(t){return r.get(t)?.body??null},async list(t=""){return[...r.keys()].filter(n=>n.startsWith(t))}}};export{a as memVault};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op0ai/sdk",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "type": "module",
   "description": "The op0 SDK — an agent with a computer: a governed function under a RunSpec (goal + stop rules + verifier), typed ports, a vendor-free core. Build agents that run on op0 (op0.ai), the governed runtime for agent work. Proprietary — free to use WITH the op0 runtime.",
   "license": "SEE LICENSE IN LICENSE",
@@ -36,14 +36,15 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "esbuild": "^0.28.1",
     "vitest": "^4.1.9"
   },
   "scripts": {
     "test": "node scripts/dep-lint.mjs && vitest run",
     "typecheck": "tsgo --noEmit -p tsconfig.json",
     "build": "tsc -p tsconfig.build.json",
-    "prepack": "node ../../scripts/publish-exports.mjs prepack",
-    "postpack": "node ../../scripts/publish-exports.mjs postpack"
+    "prepack": "npm test && node scripts/build-dist.mjs prepack",
+    "postpack": "node scripts/build-dist.mjs postpack"
   },
   "keywords": [
     "op0",

package/dist/agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAW,SAAS,EAAE,MAAM,eAAe,CAAC;AAEhG;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,WAAW,SAAS,KAAG,OA8BpD,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAC,KAAG,SAGxF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,SAAS,EAAE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,KAAG,QAAQ,EAoBrH,CAAC"}

package/dist/agent.js

@@ -1,72 +0,0 @@
-/**
- * minimalHarness — model → (tool calls)* → final text, bounded by maxSteps. The agent reasons freely but can
- * only ACT through the `tools` it's given (which are the cord's governed ports — see portsAsTools), so an
- * agent-ful cord stays inside its declared scope by construction, not by prompt.
- */
-export const minimalHarness = (inference) => ({
-    async run({ instructions, input, tools, maxSteps = 8 }) {
-        const messages = [
-            { role: "system", content: instructions },
-            { role: "user", content: input },
-        ];
-        const byName = new Map(tools.map((t) => [t.name, t]));
-        // Outer loop: genuinely sequential — each step's model call reads `messages`, which only gains this
-        // step's tool results after they're appended below; there is nothing to await concurrently across steps.
-        for (let step = 0; step < maxSteps; step++) {
-            // oxlint-disable-next-line no-await-in-loop
-            const r = await inference.generate({ messages, tools });
-            if (r.toolCalls && r.toolCalls.length > 0) {
-                // one assistant turn carrying the tool_calls, then one tool turn per result (OpenAI convention; the
-                // adapter maps it to the provider wire format). Unknown tools are surfaced, never thrown — self-correct.
-                messages.push({ role: "assistant", content: r.text ?? "", toolCalls: r.toolCalls });
-                // Inner loop: kept sequential too — tools are governed ports (kv_incr etc.) whose side effects can
-                // be order-sensitive; parallelizing would reorder effects the model issued in a specific sequence.
-                for (const tc of r.toolCalls) {
-                    const tool = byName.get(tc.name);
-                    // oxlint-disable-next-line no-await-in-loop
-                    const result = tool ? await tool.run(tc.args) : { error: `unknown tool: ${tc.name}` };
-                    messages.push({ role: "tool", content: JSON.stringify(result), toolCallId: tc.id });
-                }
-                continue; // let the model see the tool results and decide next
-            }
-            return { output: r.text ?? "", steps: step + 1 };
-        }
-        throw new Error(`harness: maxSteps ${maxSteps} exhausted without a final answer`);
-    },
-});
-/**
- * fakeInference — a scripted model for TDD (no network, deterministic). Pass the exact turn sequence the loop
- * should see: each entry is either tool calls or final text. This is how the agent loop is unit-tested; the
- * real adapter (AI Gateway / Anthropic) plugs into the same Inference port at deploy.
- */
-export const fakeInference = (script) => {
-    let i = 0;
-    return { async generate() { return script[i++] ?? { text: "(script exhausted)" }; } };
-};
-/**
- * portsAsTools — expose selected resource ports to the agent as callable tools. THIS is governed-tools = ports:
- * the agent can only act through capabilities the cord declared + the host bound. `onTool` lets the cord audit
- * every call (one wide-event per action). ponytail: only the ports you pass become tools — nothing else.
- */
-export const portsAsTools = (res, onTool) => {
-    const tools = [];
-    if (res.kv) {
-        tools.push({
-            name: "kv_incr",
-            description: "Increment a durable counter by key. args: { key: string, by?: number }",
-            parameters: { type: "object", properties: { key: { type: "string" }, by: { type: "number" } }, required: ["key"] },
-            run: async (a) => { onTool?.("kv_incr", a); return { count: await res.kv.incr(String(a['key']), typeof a['by'] === "number" ? a['by'] : 1) }; },
-        });
-    }
-    if (res.vault) {
-        tools.push({
-            name: "vault_put",
-            description: "Persist a deliverable. args: { key: string, body: string }",
-            parameters: { type: "object", properties: { key: { type: "string" }, body: { type: "string" } }, required: ["key", "body"] },
-            run: async (a) => { onTool?.("vault_put", a); return await res.vault.put(String(a['key']), String(a['body'])); },
-        });
-    }
-    // add source/sql/vector tools here as a cord needs them (ponytail: not before)
-    return tools;
-};
-//# sourceMappingURL=agent.js.map

package/dist/agent.js.map

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

package/dist/agui.d.ts.map

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

package/dist/agui.js

@@ -1,22 +0,0 @@
-// agui.ts — the cord's event layer: a typed, AG-UI-aligned stream of what the cord is doing. It is THREE things
-// at once: (1) the cord↔UI wire (AG-UI), (2) the observability story (one event per step — the "stack trace" the
-// playground renders in motion), and (3) what the thin typed client consumes. Events are plain JSON so the host
-// can persist them on the DO (durable → the timeline survives reload) and replay them to a reconnecting client.
-// Hoisted from inside createEmitter (captures nothing — pure).
-const now = () => Date.now();
-export function createEmitter(runId, sink) {
-    const send = (event) => sink(event);
-    return {
-        runId,
-        started: (threadId) => send({ type: "RUN_STARTED", runId, threadId, ts: now() }),
-        text: (delta) => send({ type: "TEXT_MESSAGE_CONTENT", runId, delta, ts: now() }),
-        toolStart: (toolCallId, name, args) => send({ type: "TOOL_CALL_START", runId, toolCallId, name, args, ts: now() }),
-        toolResult: (r) => send({ type: "TOOL_CALL_RESULT", runId, ...r, ts: now() }),
-        sourceStaged: (path) => send({ type: "SOURCE_STAGED", runId, path, ts: now() }),
-        sourceCommitted: (paths, external) => send({ type: "SOURCE_COMMITTED", runId, paths, external, ts: now() }),
-        stateDelta: (patch) => send({ type: "STATE_DELTA", runId, patch, ts: now() }),
-        finished: () => send({ type: "RUN_FINISHED", runId, ts: now() }),
-        errored: (error) => send({ type: "RUN_ERROR", runId, error, ts: now() }),
-    };
-}
-//# sourceMappingURL=agui.js.map

package/dist/agui.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"agui.js","sourceRoot":"","sources":["../src/agui.ts"],"names":[],"mappings":"AAAA,gHAAgH;AAChH,iHAAiH;AACjH,gHAAgH;AAChH,gHAAgH;AAoChH,+DAA+D;AAC/D,MAAM,GAAG,GAAG,GAAW,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;AAErC,MAAM,UAAU,aAAa,CAAC,KAAa,EAAE,IAAoB;IAC/D,MAAM,IAAI,GAAG,CAAC,KAAiB,EAAQ,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtD,OAAO;QACL,KAAK;QACL,OAAO,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QAChF,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,sBAAsB,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QAChF,SAAS,EAAE,CAAC,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QAClH,UAAU,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QAC7E,YAAY,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QAC/E,eAAe,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QAC3G,UAAU,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QAC7E,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QAChE,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;KACzE,CAAC;AACJ,CAAC"}