@sapiom/tools 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sapiom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# @sapiom/tools
+
+A typed TypeScript client for Sapiom capabilities — sandboxes, git repositories, and coding agents — authenticated to your tenant.
+
+These are the same capabilities your Sapiom agents call as tools; this package makes them callable directly from your own code.
+
+```bash
+npm install @sapiom/tools
+# or
+pnpm add @sapiom/tools
+```
+
+## Quickstart
+
+```typescript
+import { createClient } from "@sapiom/tools";
+
+const sapiom = createClient({ apiKey: process.env.SAPIOM_API_KEY });
+
+// Create a repo, have a coding agent build into it, then publish.
+const repo = await sapiom.repositories.create("landing-page");
+const run = await sapiom.agent.coding.run({
+  task: "Build a one-page marketing site in index.html.",
+  gitRepository: repo, // cloned into the run's sandbox at /workspace/landing-page
+});
+
+if (run.result?.success) {
+  const { sha } = await repo.pushFromSandbox(run.sandbox, { message: "build: landing" });
+  console.log("published", sha);
+}
+```
+
+## Authentication
+
+There are two ways to authenticate, both exposing the identical capability surface:
+
+- **Explicit** — pass a key to `createClient`. This is the standalone entry point:
+  ```typescript
+  const sapiom = createClient({ apiKey: process.env.SAPIOM_API_KEY });
+  await sapiom.sandboxes.create({ name: "demo" });
+  ```
+- **Ambient** — import the namespaces directly and they resolve credentials from `SAPIOM_API_KEY` (or, inside a Sapiom workflow step, from the client the runtime provides):
+  ```typescript
+  import { sandboxes, repositories, agent } from "@sapiom/tools";
+  await sandboxes.create({ name: "demo" });
+  ```
+
+## Attribution
+
+Calls can be attributed to an agent and trace so they show up correctly in your transaction history. Attribution is set **once, on the client** — not per call:
+
+```typescript
+const sapiom = createClient({
+  apiKey: process.env.SAPIOM_API_KEY,
+  attribution: { agentName: "digest-bot", traceId },
+});
+// every call this client makes is now attributed to digest-bot / traceId
+```
+
+Inside a Sapiom workflow you don't set this at all — the runtime constructs the client with the running execution's attribution, so every tool call is attributed automatically.
+
+If a single process makes calls on behalf of more than one agent or trace, derive a client per context with `sapiom.withAttribution({ ... })`.
+
+## Capabilities
+
+Each capability is a namespace, importable from the barrel or its own subpath (e.g. `@sapiom/tools/sandboxes`). Every capability has its own README with usage details, preconditions, and gotchas the type signatures can't express — read it before first use.
+
+| Namespace | What it is | Docs |
+|---|---|---|
+| `sandboxes` | Isolated, ephemeral compute | [src/sandboxes](./src/sandboxes/README.md) |
+| `repositories` | Private, in-network git repos | [src/repositories](./src/repositories/README.md) |
+| `agent` | Coding agents (LLM execution) | [src/agent](./src/agent/README.md) |
+
+## Composing capabilities
+
+Capabilities are designed to work together. A coding `agent` run hands back the live `Sandbox` it executed in, and a `Repository` can publish a working tree straight from that sandbox:
+
+```typescript
+const run = await agent.coding.run({ task, gitRepository: repo });
+await repo.pushFromSandbox(run.sandbox);
+```
+
+A useful pattern: let the agent do the open-ended work (writing files) and perform exact, repeatable actions — committing, pushing, deploying — in your own code rather than in the agent's prompt. The agent produces the changes; `pushFromSandbox` publishes them deterministically.
+
+## License
+
+MIT

package/dist/cjs/_client/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Auth + transport core for `@sapiom/tools` — the private "runtime half" every
+ * capability namespace wraps. Capability modules call THIS; they never import each
+ * other's runtime, so the cross-capability mesh (`repo.pushFromSandbox(sandbox)`)
+ * has no package/module cycles. See docs/plans/capability-authoring-sdk.md.
+ *
+ * The credential resolves from one of two sources, same surface either way:
+ *   - explicit:  createClient({ apiKey })  — standalone / open-source use
+ *   - ambient:   SAPIOM_API_KEY (env), which the workflow engine injects per
+ *                execution so step authors write zero auth plumbing.
+ *
+ * Attribution (which agent / trace a call belongs to) is execution context the
+ * runtime owns, NOT a parameter of any operation — so it lives here on the
+ * transport, set once and injected on every request, never threaded through
+ * capability methods. The engine sets it per execution by constructing the
+ * per-execution client; `withAttribution(...)` is a quiet escape hatch for the
+ * router / standalone cases. Capability method signatures deliberately have no
+ * attribution argument: that absence keeps LLM-authored step code from setting
+ * (and getting wrong) context it doesn't own.
+ */
+/**
+ * Per-request attribution recorded with the gateway transaction. Every field is
+ * optional and maps 1:1 to an `x-sapiom-*` header the collapsed flow understands.
+ */
+export interface Attribution {
+    /** Human-readable agent name. Mutually exclusive with `agentId` (gateway-enforced). */
+    agentName?: string;
+    /** Agent UUID. Mutually exclusive with `agentName` (gateway-enforced). */
+    agentId?: string;
+    /** Sapiom trace id to attribute this call to. */
+    traceId?: string;
+    /** Your own external trace / correlation id. */
+    traceExternalId?: string;
+    /** Arbitrary JSON object stored with the transaction. Must be an object. */
+    metadata?: Record<string, unknown>;
+}
+export interface TransportConfig {
+    /** Explicit tenant API key. Omit inside a workflow step — the engine injects it ambiently. */
+    apiKey?: string;
+    /** Inject a fetch (tests / non-standard runtimes). Defaults to global fetch. */
+    fetch?: typeof globalThis.fetch;
+    /** Default attribution applied to every request this transport makes (see class doc). */
+    attribution?: Attribution;
+}
+export declare class Transport {
+    private readonly apiKey;
+    private readonly fetchImpl;
+    private readonly attribution;
+    constructor(config?: TransportConfig);
+    /**
+     * A new transport sharing this one's credential and fetch, with `attribution`
+     * merged over the current defaults. The escape hatch for the cases where one
+     * process attributes to many agents/traces (a router) — not something
+     * step-authoring code reaches for.
+     */
+    withAttribution(attribution: Attribution): Transport;
+    /**
+     * Authenticated raw fetch — capabilities that need streaming or custom
+     * response handling (filesystem, log streams) use this and inspect the
+     * `Response` themselves. Injects the tenant credential + attribution headers;
+     * sets no content-type.
+     */
+    fetch(url: string, init?: RequestInit): Promise<Response>;
+    /** Authenticated JSON request — parses the body and throws on a non-2xx status. */
+    request<T>(url: string, init?: RequestInit): Promise<T>;
+}
+export declare function defaultTransport(): Transport;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/_client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/_client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,eAAe;IAC9B,8FAA8F;IAC9F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAChC,yFAAyF;IACzF,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AA4BD,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;gBAE9B,MAAM,GAAE,eAAoB;IAMxC;;;;;OAKG;IACH,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS;IAQpD;;;;;OAKG;IACG,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC;IAiBnE,mFAAmF;IAC7E,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,CAAC,CAAC;CAUlE;AAID,wBAAgB,gBAAgB,IAAI,SAAS,CAE5C"}

package/dist/cjs/_client/index.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Auth + transport core for `@sapiom/tools` — the private "runtime half" every
+ * capability namespace wraps. Capability modules call THIS; they never import each
+ * other's runtime, so the cross-capability mesh (`repo.pushFromSandbox(sandbox)`)
+ * has no package/module cycles. See docs/plans/capability-authoring-sdk.md.
+ *
+ * The credential resolves from one of two sources, same surface either way:
+ *   - explicit:  createClient({ apiKey })  — standalone / open-source use
+ *   - ambient:   SAPIOM_API_KEY (env), which the workflow engine injects per
+ *                execution so step authors write zero auth plumbing.
+ *
+ * Attribution (which agent / trace a call belongs to) is execution context the
+ * runtime owns, NOT a parameter of any operation — so it lives here on the
+ * transport, set once and injected on every request, never threaded through
+ * capability methods. The engine sets it per execution by constructing the
+ * per-execution client; `withAttribution(...)` is a quiet escape hatch for the
+ * router / standalone cases. Capability method signatures deliberately have no
+ * attribution argument: that absence keeps LLM-authored step code from setting
+ * (and getting wrong) context it doesn't own.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transport = void 0;
+exports.defaultTransport = defaultTransport;
+function attributionToHeaders(a) {
+    const h = {};
+    if (a.agentName)
+        h["x-sapiom-agent-name"] = a.agentName;
+    if (a.agentId)
+        h["x-sapiom-agent-id"] = a.agentId;
+    if (a.traceId)
+        h["x-sapiom-trace-id"] = a.traceId;
+    if (a.traceExternalId)
+        h["x-sapiom-trace-external-id"] = a.traceExternalId;
+    if (a.metadata)
+        h["x-sapiom-metadata"] = JSON.stringify(a.metadata);
+    return h;
+}
+/**
+ * Standalone-only ambient attribution. Read once for the process-global default
+ * transport. NOT the engine's injection channel — `process.env` is process-wide,
+ * so it would bleed across step executions that share a worker. The engine sets
+ * attribution by constructing the per-execution client instead. Safe only for the
+ * one-execution-per-process case (CLI, scripts).
+ */
+function attributionFromEnv() {
+    const a = {};
+    if (process.env.SAPIOM_AGENT_ID)
+        a.agentId = process.env.SAPIOM_AGENT_ID;
+    if (process.env.SAPIOM_AGENT_NAME)
+        a.agentName = process.env.SAPIOM_AGENT_NAME;
+    if (process.env.SAPIOM_TRACE_ID)
+        a.traceId = process.env.SAPIOM_TRACE_ID;
+    if (process.env.SAPIOM_TRACE_EXTERNAL_ID)
+        a.traceExternalId = process.env.SAPIOM_TRACE_EXTERNAL_ID;
+    return a;
+}
+class Transport {
+    constructor(config = {}) {
+        this.apiKey = config.apiKey ?? process.env.SAPIOM_API_KEY ?? undefined;
+        this.fetchImpl = config.fetch ?? globalThis.fetch;
+        this.attribution = config.attribution ?? {};
+    }
+    /**
+     * A new transport sharing this one's credential and fetch, with `attribution`
+     * merged over the current defaults. The escape hatch for the cases where one
+     * process attributes to many agents/traces (a router) — not something
+     * step-authoring code reaches for.
+     */
+    withAttribution(attribution) {
+        return new Transport({
+            apiKey: this.apiKey,
+            fetch: this.fetchImpl,
+            attribution: { ...this.attribution, ...attribution },
+        });
+    }
+    /**
+     * Authenticated raw fetch — capabilities that need streaming or custom
+     * response handling (filesystem, log streams) use this and inspect the
+     * `Response` themselves. Injects the tenant credential + attribution headers;
+     * sets no content-type.
+     */
+    async fetch(url, init = {}) {
+        if (!this.apiKey) {
+            throw new Error("@sapiom/tools: no tenant credential. Pass createClient({ apiKey }) for standalone use, " +
+                "or run inside a Sapiom workflow (the engine injects SAPIOM_API_KEY).");
+        }
+        return this.fetchImpl(url, {
+            ...init,
+            headers: {
+                "x-sapiom-api-key": this.apiKey,
+                ...attributionToHeaders(this.attribution),
+                ...(init.headers ?? {}),
+            },
+        });
+    }
+    /** Authenticated JSON request — parses the body and throws on a non-2xx status. */
+    async request(url, init = {}) {
+        const res = await this.fetch(url, {
+            ...init,
+            headers: { "content-type": "application/json", ...(init.headers ?? {}) },
+        });
+        if (!res.ok) {
+            throw new Error(`${init.method ?? "GET"} ${url} → ${res.status} ${await res.text()}`);
+        }
+        return (await res.json());
+    }
+}
+exports.Transport = Transport;
+/** The ambient default transport used by barrel-imported capabilities when no client is supplied. */
+let _default;
+function defaultTransport() {
+    return (_default ?? (_default = new Transport({ attribution: attributionFromEnv() })));
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/_client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/_client/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AAqHH,4CAEC;AA3FD,SAAS,oBAAoB,CAAC,CAAc;IAC1C,MAAM,CAAC,GAA2B,EAAE,CAAC;IACrC,IAAI,CAAC,CAAC,SAAS;QAAE,CAAC,CAAC,qBAAqB,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC;IACxD,IAAI,CAAC,CAAC,OAAO;QAAE,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;IAClD,IAAI,CAAC,CAAC,OAAO;QAAE,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;IAClD,IAAI,CAAC,CAAC,eAAe;QAAE,CAAC,CAAC,4BAA4B,CAAC,GAAG,CAAC,CAAC,eAAe,CAAC;IAC3E,IAAI,CAAC,CAAC,QAAQ;QAAE,CAAC,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IACpE,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;;GAMG;AACH,SAAS,kBAAkB;IACzB,MAAM,CAAC,GAAgB,EAAE,CAAC;IAC1B,IAAI,OAAO,CAAC,GAAG,CAAC,eAAe;QAAE,CAAC,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC;IACzE,IAAI,OAAO,CAAC,GAAG,CAAC,iBAAiB;QAAE,CAAC,CAAC,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC;IAC/E,IAAI,OAAO,CAAC,GAAG,CAAC,eAAe;QAAE,CAAC,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC;IACzE,IAAI,OAAO,CAAC,GAAG,CAAC,wBAAwB;QAAE,CAAC,CAAC,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC;IACnG,OAAO,CAAC,CAAC;AACX,CAAC;AAED,MAAa,SAAS;IAKpB,YAAY,SAA0B,EAAE;QACtC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,SAAS,CAAC;QACvE,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,KAAK,IAAI,UAAU,CAAC,KAAK,CAAC;QAClD,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,EAAE,CAAC;IAC9C,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAC,WAAwB;QACtC,OAAO,IAAI,SAAS,CAAC;YACnB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,SAAS;YACrB,WAAW,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE,GAAG,WAAW,EAAE;SACrD,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK,CAAC,GAAW,EAAE,OAAoB,EAAE;QAC7C,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CACb,yFAAyF;gBACvF,sEAAsE,CACzE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE;YACzB,GAAG,IAAI;YACP,OAAO,EAAE;gBACP,kBAAkB,EAAE,IAAI,CAAC,MAAM;gBAC/B,GAAG,oBAAoB,CAAC,IAAI,CAAC,WAAW,CAAC;gBACzC,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC;aACxB;SACF,CAAC,CAAC;IACL,CAAC;IAED,mFAAmF;IACnF,KAAK,CAAC,OAAO,CAAI,GAAW,EAAE,OAAoB,EAAE;QAClD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE;YAChC,GAAG,IAAI;YACP,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE;SACzE,CAAC,CAAC;QACH,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,CAAC,MAAM,IAAI,KAAK,IAAI,GAAG,MAAM,GAAG,CAAC,MAAM,IAAI,MAAM,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACxF,CAAC;QACD,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAM,CAAC;IACjC,CAAC;CACF;AA3DD,8BA2DC;AAED,qGAAqG;AACrG,IAAI,QAA+B,CAAC;AACpC,SAAgB,gBAAgB;IAC9B,OAAO,CAAC,QAAQ,KAAR,QAAQ,GAAK,IAAI,SAAS,CAAC,EAAE,WAAW,EAAE,kBAAkB,EAAE,EAAE,CAAC,EAAC,CAAC;AAC7E,CAAC"}

package/dist/cjs/agent/index.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `agent` capability — LLM execution (coding agents). The fuzzy counterpart to a
+ * deterministic step: hand it a task in natural language, it edits a checkout in a
+ * sandbox.
+ *
+ *   import { agent, repositories } from "@sapiom/tools";
+ *   const repo = await repositories.create("landing");
+ *   const run = await agent.coding.run({
+ *     task: "Build a one-page landing site in index.html.",
+ *     gitRepository: repo,        // auto-cloned into the sandbox at /workspace/<slug>
+ *   });
+ *   await repo.pushFromSandbox(run.sandbox, { message: "build: landing" });
+ *
+ * `run` awaits completion; `launch` returns a handle to poll yourself. Both return
+ * a live `Sandbox` handle so a later step can read files, exec, or push from it.
+ * The cross-capability inputs (`gitRepository: Repository`, `sandbox: Sandbox`) are
+ * passed as instances and resolved here to their wire ids.
+ *
+ * The wire contract is the gateway's JSON:API-shaped envelope (`data.attributes` /
+ * `data.relationships.execution_environment`). Attributes are snake_case on the
+ * wire; this module maps them to the camelCase SDK surface below.
+ */
+import { Transport } from "../_client/index.js";
+import { Sandbox } from "../sandboxes/index.js";
+import type { Repository } from "../repositories/index.js";
+/** Run lifecycle, mirrored from the gateway's `AgentsRunStatus`. */
+export type RunStatus = "pending" | "queued" | "running" | "completed" | "failed";
+export interface CodingRunSpec {
+    /** Natural-language instruction for the coding agent. */
+    task: string;
+    /** Repo to clone into the sandbox at `/workspace/<slug>` and operate on. */
+    gitRepository?: Repository;
+    /** Reuse an existing sandbox instead of provisioning a fresh one. */
+    sandbox?: Sandbox;
+    /** Subdirectory (under the runner root) the agent SDK runs in. */
+    workingDirectory?: string;
+    /** Keep the sandbox alive after the run finishes. SDK default: true (the mesh needs it). */
+    keepSandbox?: boolean;
+    /** Override the model the agent runs on. */
+    model?: string;
+}
+export interface CodingRunUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreateTokens: number;
+    thinkingTokens: number;
+}
+export interface CodingRunOutcome {
+    success: boolean;
+    turns: number;
+    modelUsed: string | null;
+    durationMs: number;
+    toolCallCount: number;
+    usage: CodingRunUsage;
+}
+export interface CodingRunError {
+    /** `launch` (failed before the agent ran) vs `run` (failed mid-execution). */
+    stage: string;
+    message: string;
+}
+export interface CodingRunResult {
+    runId: string;
+    status: RunStatus;
+    summary: string | null;
+    result: CodingRunOutcome | null;
+    error: CodingRunError | null;
+    /** Live handle to the sandbox the run executed in. */
+    sandbox: Sandbox;
+}
+/** A launched-but-not-awaited run. */
+export interface RunHandle {
+    runId: string;
+    sandbox: Sandbox;
+    /** Fetch the current status without blocking. */
+    status(): Promise<RunStatus>;
+    /** Poll to a terminal state and resolve the full result. */
+    wait(opts?: {
+        timeoutMs?: number;
+        pollMs?: number;
+    }): Promise<CodingRunResult>;
+}
+export declare function launch(spec: CodingRunSpec, transport?: Transport, baseUrl?: string): Promise<RunHandle>;
+export declare function run(spec: CodingRunSpec, transport?: Transport, baseUrl?: string): Promise<CodingRunResult>;
+/** Ambient-bound `agent.coding` namespace. */
+export declare const coding: {
+    run: typeof run;
+    launch: typeof launch;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/agent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAE,SAAS,EAAoB,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAI3D,oEAAoE;AACpE,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;AAGlF,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,aAAa,CAAC,EAAE,UAAU,CAAC;IAC3B,qEAAqE;IACrE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,kEAAkE;IAClE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,4FAA4F;IAC5F,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,cAAc,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,8EAA8E;IAC9E,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAChC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;IAC7B,sDAAsD;IACtD,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,sCAAsC;AACtC,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,iDAAiD;IACjD,MAAM,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC;IAC7B,4DAA4D;IAC5D,IAAI,CAAC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CAChF;AA6DD,wBAAsB,MAAM,CAC1B,IAAI,EAAE,aAAa,EACnB,SAAS,GAAE,SAA8B,EACzC,OAAO,SAAmB,GACzB,OAAO,CAAC,SAAS,CAAC,CA0CpB;AAED,wBAAsB,GAAG,CACvB,IAAI,EAAE,aAAa,EACnB,SAAS,GAAE,SAA8B,EACzC,OAAO,SAAmB,GACzB,OAAO,CAAC,eAAe,CAAC,CAG1B;AAED,8CAA8C;AAC9C,eAAO,MAAM,MAAM;;;CAAkB,CAAC"}

package/dist/cjs/agent/index.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coding = void 0;
+exports.launch = launch;
+exports.run = run;
+/**
+ * `agent` capability — LLM execution (coding agents). The fuzzy counterpart to a
+ * deterministic step: hand it a task in natural language, it edits a checkout in a
+ * sandbox.
+ *
+ *   import { agent, repositories } from "@sapiom/tools";
+ *   const repo = await repositories.create("landing");
+ *   const run = await agent.coding.run({
+ *     task: "Build a one-page landing site in index.html.",
+ *     gitRepository: repo,        // auto-cloned into the sandbox at /workspace/<slug>
+ *   });
+ *   await repo.pushFromSandbox(run.sandbox, { message: "build: landing" });
+ *
+ * `run` awaits completion; `launch` returns a handle to poll yourself. Both return
+ * a live `Sandbox` handle so a later step can read files, exec, or push from it.
+ * The cross-capability inputs (`gitRepository: Repository`, `sandbox: Sandbox`) are
+ * passed as instances and resolved here to their wire ids.
+ *
+ * The wire contract is the gateway's JSON:API-shaped envelope (`data.attributes` /
+ * `data.relationships.execution_environment`). Attributes are snake_case on the
+ * wire; this module maps them to the camelCase SDK surface below.
+ */
+const index_js_1 = require("../_client/index.js");
+const index_js_2 = require("../sandboxes/index.js");
+const DEFAULT_BASE_URL = process.env.SAPIOM_AGENTS_URL || "https://agents.services.sapiom.ai";
+const TERMINAL = new Set(["completed", "failed"]);
+function mapResult(r) {
+    if (!r)
+        return null;
+    return {
+        success: r.success,
+        turns: r.turns,
+        modelUsed: r.model_used ?? null,
+        durationMs: r.duration_ms,
+        toolCallCount: r.tool_call_count,
+        usage: {
+            inputTokens: r.usage?.input_tokens ?? 0,
+            outputTokens: r.usage?.output_tokens ?? 0,
+            cacheReadTokens: r.usage?.cache_read_tokens ?? 0,
+            cacheCreateTokens: r.usage?.cache_create_tokens ?? 0,
+            thinkingTokens: r.usage?.thinking_tokens ?? 0,
+        },
+    };
+}
+function buildBody(spec) {
+    return {
+        task: spec.task,
+        git_repository: spec.gitRepository?.slug,
+        execution_environment_id: spec.sandbox?.name,
+        working_directory: spec.workingDirectory,
+        keep_sandbox: spec.keepSandbox ?? true,
+        model: spec.model,
+    };
+}
+async function launch(spec, transport = (0, index_js_1.defaultTransport)(), baseUrl = DEFAULT_BASE_URL) {
+    // 202 + a launch document; the execution_environment relationship is always present.
+    const doc = await transport.request(`${baseUrl}/v1/coding/runs`, {
+        method: "POST",
+        body: JSON.stringify(buildBody(spec)),
+    });
+    const runId = doc.data.id;
+    const envId = doc.data.relationships?.execution_environment?.data?.id;
+    // Reuse the caller's sandbox handle when they supplied one; otherwise adopt the
+    // environment the run provisioned (its id is the sandbox name) so later steps
+    // can act on it.
+    const sandbox = spec.sandbox ?? index_js_2.Sandbox.attach(envId ?? runId, {}, transport);
+    const fetchDoc = () => transport.request(`${baseUrl}/v1/coding/runs/${encodeURIComponent(runId)}`);
+    const toResult = (d) => ({
+        runId,
+        status: d.data.attributes.status,
+        summary: d.data.attributes.summary ?? null,
+        result: mapResult(d.data.attributes.result),
+        error: d.data.attributes.error ?? null,
+        sandbox,
+    });
+    return {
+        runId,
+        sandbox,
+        async status() {
+            return (await fetchDoc()).data.attributes.status;
+        },
+        async wait({ timeoutMs = 20 * 60000, pollMs = 3000 } = {}) {
+            const deadline = Date.now() + timeoutMs;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const d = await fetchDoc();
+                if (TERMINAL.has(d.data.attributes.status))
+                    return toResult(d);
+                if (Date.now() > deadline) {
+                    throw new Error(`coding run ${runId} timed out after ${timeoutMs}ms (last status: ${d.data.attributes.status})`);
+                }
+                await new Promise((r) => setTimeout(r, pollMs));
+            }
+        },
+    };
+}
+async function run(spec, transport = (0, index_js_1.defaultTransport)(), baseUrl = DEFAULT_BASE_URL) {
+    const handle = await launch(spec, transport, baseUrl);
+    return handle.wait();
+}
+/** Ambient-bound `agent.coding` namespace. */
+exports.coding = { run, launch };
+//# sourceMappingURL=index.js.map

package/dist/cjs/agent/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/agent/index.ts"],"names":[],"mappings":";;;AAqJA,wBA8CC;AAED,kBAOC;AA5MD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,kDAAkE;AAClE,oDAAgD;AAGhD,MAAM,gBAAgB,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,mCAAmC,CAAC;AAI9F,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAY,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;AA0F7D,SAAS,SAAS,CAAC,CAAgC;IACjD,IAAI,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACpB,OAAO;QACL,OAAO,EAAE,CAAC,CAAC,OAAO;QAClB,KAAK,EAAE,CAAC,CAAC,KAAK;QACd,SAAS,EAAE,CAAC,CAAC,UAAU,IAAI,IAAI;QAC/B,UAAU,EAAE,CAAC,CAAC,WAAW;QACzB,aAAa,EAAE,CAAC,CAAC,eAAe;QAChC,KAAK,EAAE;YACL,WAAW,EAAE,CAAC,CAAC,KAAK,EAAE,YAAY,IAAI,CAAC;YACvC,YAAY,EAAE,CAAC,CAAC,KAAK,EAAE,aAAa,IAAI,CAAC;YACzC,eAAe,EAAE,CAAC,CAAC,KAAK,EAAE,iBAAiB,IAAI,CAAC;YAChD,iBAAiB,EAAE,CAAC,CAAC,KAAK,EAAE,mBAAmB,IAAI,CAAC;YACpD,cAAc,EAAE,CAAC,CAAC,KAAK,EAAE,eAAe,IAAI,CAAC;SAC9C;KACF,CAAC;AACJ,CAAC;AAED,SAAS,SAAS,CAAC,IAAmB;IACpC,OAAO;QACL,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,cAAc,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI;QACxC,wBAAwB,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI;QAC5C,iBAAiB,EAAE,IAAI,CAAC,gBAAgB;QACxC,YAAY,EAAE,IAAI,CAAC,WAAW,IAAI,IAAI;QACtC,KAAK,EAAE,IAAI,CAAC,KAAK;KAClB,CAAC;AACJ,CAAC;AAEM,KAAK,UAAU,MAAM,CAC1B,IAAmB,EACnB,YAAuB,IAAA,2BAAgB,GAAE,EACzC,OAAO,GAAG,gBAAgB;IAE1B,qFAAqF;IACrF,MAAM,GAAG,GAAG,MAAM,SAAS,CAAC,OAAO,CAAS,GAAG,OAAO,iBAAiB,EAAE;QACvE,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;KACtC,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;IAC1B,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,qBAAqB,EAAE,IAAI,EAAE,EAAE,CAAC;IACtE,gFAAgF;IAChF,8EAA8E;IAC9E,iBAAiB;IACjB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,kBAAO,CAAC,MAAM,CAAC,KAAK,IAAI,KAAK,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC;IAE9E,MAAM,QAAQ,GAAG,GAAG,EAAE,CAAC,SAAS,CAAC,OAAO,CAAS,GAAG,OAAO,mBAAmB,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC3G,MAAM,QAAQ,GAAG,CAAC,CAAS,EAAmB,EAAE,CAAC,CAAC;QAChD,KAAK;QACL,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM;QAChC,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,IAAI,IAAI;QAC1C,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;QAC3C,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,IAAI,IAAI;QACtC,OAAO;KACR,CAAC,CAAC;IAEH,OAAO;QACL,KAAK;QACL,OAAO;QACP,KAAK,CAAC,MAAM;YACV,OAAO,CAAC,MAAM,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;QACnD,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,EAAE,GAAG,KAAM,EAAE,MAAM,GAAG,IAAK,EAAE,GAAG,EAAE;YACzD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;YACxC,iDAAiD;YACjD,OAAO,IAAI,EAAE,CAAC;gBACZ,MAAM,CAAC,GAAG,MAAM,QAAQ,EAAE,CAAC;gBAC3B,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;oBAAE,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC/D,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;oBAC1B,MAAM,IAAI,KAAK,CAAC,cAAc,KAAK,oBAAoB,SAAS,oBAAoB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;gBACnH,CAAC;gBACD,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC;AAEM,KAAK,UAAU,GAAG,CACvB,IAAmB,EACnB,YAAuB,IAAA,2BAAgB,GAAE,EACzC,OAAO,GAAG,gBAAgB;IAE1B,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACtD,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC;AACvB,CAAC;AAED,8CAA8C;AACjC,QAAA,MAAM,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC"}

package/dist/cjs/client.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `createClient` — builds a `Sapiom` client whose capability namespaces are bound
+ * to an explicit credential. This is the standalone / open-source entry point:
+ *
+ *   import { createClient } from "@sapiom/tools";
+ *   const sapiom = createClient({ apiKey: process.env.SAPIOM_API_KEY });
+ *   const box = await sapiom.sandboxes.create({ name: "demo" });
+ *
+ * Inside a workflow step the engine hands you an already-auth'd `sapiom` of this
+ * same shape; you can also barrel-import the ambient-bound namespaces directly
+ * (`import { sandboxes } from "@sapiom/tools"`).
+ *
+ * Attribution is set once (the engine constructs the per-execution client with
+ * it; standalone callers pass it to `createClient`), never per capability call.
+ * `withAttribution(...)` derives a client for the router case — see `_client`.
+ */
+import { type TransportConfig, type Attribution } from "./_client/index.js";
+import { Sandbox } from "./sandboxes/index.js";
+import type { SandboxCreateOptions } from "./sandboxes/index.js";
+import { Repository } from "./repositories/index.js";
+import type { CodingRunSpec, CodingRunResult, RunHandle } from "./agent/index.js";
+export interface Sapiom {
+    readonly sandboxes: {
+        create(opts: SandboxCreateOptions): Promise<Sandbox>;
+        attach(name: string, opts?: {
+            workspaceRoot?: string;
+            baseUrl?: string;
+        }): Sandbox;
+    };
+    readonly repositories: {
+        create(slug: string): Promise<Repository>;
+        get(slug: string): Promise<Repository>;
+        list(): Promise<Repository[]>;
+        delete(slug: string): Promise<void>;
+        attach(slug: string, cloneUrl: string): Repository;
+    };
+    readonly agent: {
+        coding: {
+            run(spec: CodingRunSpec): Promise<CodingRunResult>;
+            launch(spec: CodingRunSpec): Promise<RunHandle>;
+        };
+    };
+    /**
+     * Derive a client that attributes its calls to a different agent/trace. For the
+     * router case (one process acting for many agents); step-authoring code doesn't
+     * need this — attribution is set once when the client is constructed.
+     */
+    withAttribution(attribution: Attribution): Sapiom;
+}
+export declare function createClient(config?: TransportConfig): Sapiom;
+//# sourceMappingURL=client.d.ts.map

package/dist/cjs/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAa,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElF,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,SAAS,EAAE;QAClB,MAAM,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QACrD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;YAAE,aAAa,CAAC,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,OAAO,CAAC;KACpF,CAAC;IACF,QAAQ,CAAC,YAAY,EAAE;QACrB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;QAC1C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;QACvC,IAAI,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;QAC9B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QACpC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAC;KACpD,CAAC;IACF,QAAQ,CAAC,KAAK,EAAE;QACd,MAAM,EAAE;YACN,GAAG,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;YACnD,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;SACjD,CAAC;KACH,CAAC;IACF;;;;OAIG;IACH,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAAC;CAEnD;AA0BD,wBAAgB,YAAY,CAAC,MAAM,CAAC,EAAE,eAAe,GAAG,MAAM,CAE7D"}

package/dist/cjs/client.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = createClient;
+/**
+ * `createClient` — builds a `Sapiom` client whose capability namespaces are bound
+ * to an explicit credential. This is the standalone / open-source entry point:
+ *
+ *   import { createClient } from "@sapiom/tools";
+ *   const sapiom = createClient({ apiKey: process.env.SAPIOM_API_KEY });
+ *   const box = await sapiom.sandboxes.create({ name: "demo" });
+ *
+ * Inside a workflow step the engine hands you an already-auth'd `sapiom` of this
+ * same shape; you can also barrel-import the ambient-bound namespaces directly
+ * (`import { sandboxes } from "@sapiom/tools"`).
+ *
+ * Attribution is set once (the engine constructs the per-execution client with
+ * it; standalone callers pass it to `createClient`), never per capability call.
+ * `withAttribution(...)` derives a client for the router case — see `_client`.
+ */
+const index_js_1 = require("./_client/index.js");
+const index_js_2 = require("./sandboxes/index.js");
+const index_js_3 = require("./repositories/index.js");
+const index_js_4 = require("./agent/index.js");
+/** Bind every capability namespace to a transport. `withAttribution` rebinds to a derived one. */
+function bind(transport) {
+    return {
+        sandboxes: {
+            create: (opts) => index_js_2.Sandbox.create(opts, transport),
+            attach: (name, opts) => index_js_2.Sandbox.attach(name, opts, transport),
+        },
+        repositories: {
+            create: (slug) => index_js_3.Repository.create(slug, transport),
+            get: (slug) => index_js_3.Repository.get(slug, transport),
+            list: () => index_js_3.Repository.list(transport),
+            delete: (slug) => index_js_3.Repository.delete(slug, transport),
+            attach: (slug, cloneUrl) => index_js_3.Repository.attach(slug, cloneUrl, transport),
+        },
+        agent: {
+            coding: {
+                run: (spec) => (0, index_js_4.run)(spec, transport),
+                launch: (spec) => (0, index_js_4.launch)(spec, transport),
+            },
+        },
+        withAttribution: (attribution) => bind(transport.withAttribution(attribution)),
+    };
+}
+function createClient(config) {
+    return bind(new index_js_1.Transport(config));
+}
+//# sourceMappingURL=client.js.map

package/dist/cjs/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":";;AA0EA,oCAEC;AA5ED;;;;;;;;;;;;;;;GAeG;AACH,iDAAuF;AACvF,mDAA+C;AAE/C,sDAAqD;AACrD,+CAA4E;AA8B5E,kGAAkG;AAClG,SAAS,IAAI,CAAC,SAAoB;IAChC,OAAO;QACL,SAAS,EAAE;YACT,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,kBAAO,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC;YACjD,MAAM,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,kBAAO,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC;SAC9D;QACD,YAAY,EAAE;YACZ,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,qBAAU,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC;YACpD,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,qBAAU,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC;YAC9C,IAAI,EAAE,GAAG,EAAE,CAAC,qBAAU,CAAC,IAAI,CAAC,SAAS,CAAC;YACtC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,qBAAU,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC;YACpD,MAAM,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,CAAC,qBAAU,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,CAAC;SACzE;QACD,KAAK,EAAE;YACL,MAAM,EAAE;gBACN,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAA,cAAS,EAAC,IAAI,EAAE,SAAS,CAAC;gBACzC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAA,iBAAY,EAAC,IAAI,EAAE,SAAS,CAAC;aAChD;SACF;QACD,eAAe,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;KAC/E,CAAC;AACJ,CAAC;AAED,SAAgB,YAAY,CAAC,MAAwB;IACnD,OAAO,IAAI,CAAC,IAAI,oBAAS,CAAC,MAAM,CAAC,CAAC,CAAC;AACrC,CAAC"}

package/dist/cjs/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@sapiom/tools` — the typed Sapiom capability client.
+ *
+ * The same catalog your agents call over MCP, callable from code. Capabilities are
+ * namespaces (`sandboxes`, `repositories`, `agent`, … ), importable from the barrel
+ * or a subpath:
+ *
+ *   import { sandboxes } from "@sapiom/tools";
+ *   import { sandboxes } from "@sapiom/tools/sandboxes";
+ *
+ * Auth is implicit: ambient (engine-injected) inside a workflow step, or explicit
+ * via `createClient({ apiKey })` standalone.
+ */
+export { createClient } from "./client.js";
+export type { Sapiom } from "./client.js";
+export type { TransportConfig, Attribution } from "./_client/index.js";
+export * as sandboxes from "./sandboxes/index.js";
+export { Sandbox } from "./sandboxes/index.js";
+export * as repositories from "./repositories/index.js";
+export { Repository } from "./repositories/index.js";
+export * as agent from "./agent/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEvE,OAAO,KAAK,SAAS,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,OAAO,KAAK,YAAY,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAC"}