@tangle-network/agent-provider-tangle 0.5.1 → 0.6.1

package/dist/tangle-provider.js

@@ -0,0 +1,192 @@
+import { AgentEnvironmentCapabilitiesSchema } from "@tangle-network/agent-interface/environment-provider";
+import { createTangleExactProcessProvider, } from "./exact-process.js";
+import { capabilitiesForClient, defaultTangleSandboxCapabilities, } from "./tangle-capabilities.js";
+import { sandboxInstanceAsEnvironment } from "./tangle-environment.js";
+import { assertCreateInputShape, assertMappedCreateOptions, assertMappedSecretNames, assertNoInlineSecretValues, sandboxOptionsFromCreateInput } from "./tangle-create-options.js";
+import { statusFromUnknown } from "./tangle-environment-values.js";
+import { assertBoundedJson, attachCleanupHandle, awaitWithSignal, boundedIdentifier, boundedString, MAX_LIST_RESULTS, } from "./tangle-contract-safety.js";
+export function createTangleProvider(options) {
+    const providerName = options.name ?? "tangle-sandbox";
+    boundedIdentifier(providerName, "Tangle provider name");
+    const exactProcess = options.exactProcess
+        ? createTangleExactProcessProvider({
+            client: options.client,
+            options: options.exactProcess,
+            providerName,
+        })
+        : undefined;
+    const resolveCapabilities = async () => {
+        const configured = options.capabilities
+            ? typeof options.capabilities === "function"
+                ? await options.capabilities()
+                : options.capabilities
+            : defaultTangleSandboxCapabilities();
+        if (!exactProcess && configured.exactProcess) {
+            throw new Error("Tangle capabilities cannot advertise exactProcess without exactProcess configuration");
+        }
+        const withExactProcess = exactProcess
+            ? {
+                ...configured,
+                exactProcess: { egress: ["blocked", "strict"] },
+            }
+            : configured;
+        return AgentEnvironmentCapabilitiesSchema.parse(capabilitiesForClient(withExactProcess, options.client));
+    };
+    return {
+        name: providerName,
+        ...(exactProcess ? { exactProcess } : {}),
+        capabilities: resolveCapabilities,
+        ...(options.validateProfile ? { validateProfile: options.validateProfile } : {}),
+        async create(input) {
+            assertCreateInputShape(input);
+            input.signal?.throwIfAborted();
+            assertNoInlineSecretValues(input);
+            if (input.providerOptions && Object.keys(input.providerOptions).length > 0) {
+                throw new Error("Tangle create providerOptions are not supported");
+            }
+            const capabilities = await resolveCapabilities();
+            const createOptions = options.mapCreateInput?.(input) ??
+                sandboxOptionsFromCreateInput(input, options.defaultBackend ?? "opencode");
+            assertMappedCreateOptions(createOptions);
+            assertMappedSecretNames(createOptions);
+            input.signal?.throwIfAborted();
+            const createPromise = options.client.create(createOptions, input.signal ? { signal: input.signal } : undefined);
+            let box;
+            try {
+                box = await awaitWithSignal(createPromise, input.signal);
+            }
+            catch (error) {
+                if (input.signal?.aborted) {
+                    void createPromise
+                        .then(async (lateBox) => {
+                        if (!lateBox.delete) {
+                            attachCleanupHandle(error, lateBox);
+                            return;
+                        }
+                        try {
+                            await lateBox.delete();
+                        }
+                        catch (cleanupError) {
+                            attachCleanupHandle(error, lateBox, cleanupError);
+                        }
+                    })
+                        .catch((lateError) => attachCleanupHandle(error, undefined, lateError));
+                }
+                throw error;
+            }
+            try {
+                input.signal?.throwIfAborted();
+                const environment = sandboxInstanceAsEnvironment(box, providerName, options.client, capabilities);
+                input.signal?.throwIfAborted();
+                return environment;
+            }
+            catch (error) {
+                if (!box.delete) {
+                    const baseError = error instanceof Error ? error : new Error(String(error));
+                    throw Object.assign(baseError, { cleanupHandle: box });
+                }
+                try {
+                    await box.delete();
+                }
+                catch (cleanupError) {
+                    const combined = new AggregateError([error, cleanupError], "Tangle environment validation and cleanup both failed");
+                    attachCleanupHandle(combined, box, cleanupError);
+                    throw combined;
+                }
+                throw error;
+            }
+        },
+        ...(options.client.get
+            ? {
+                async get(id, operation) {
+                    assertProviderOperationOptions(operation, "Tangle get");
+                    boundedIdentifier(id, "Tangle environment id");
+                    operation?.signal?.throwIfAborted();
+                    const box = await awaitWithSignal(options.client.get?.(id, operation), operation?.signal);
+                    operation?.signal?.throwIfAborted();
+                    if (!box || boundedIdentifier(box.id, "Tangle environment id") !== id)
+                        return null;
+                    return box
+                        ? sandboxInstanceAsEnvironment(box, providerName, options.client, await resolveCapabilities())
+                        : null;
+                },
+            }
+            : {}),
+        ...(options.client.list
+            ? {
+                async list(query, operation) {
+                    assertProviderOperationOptions(operation, "Tangle list");
+                    assertEnvironmentQuery(query);
+                    operation?.signal?.throwIfAborted();
+                    if (query?.name !== undefined)
+                        boundedString(query.name, "Tangle environment query name");
+                    if (query?.providerOptions && Object.keys(query.providerOptions).length > 0) {
+                        throw new Error("Tangle environment list providerOptions are not supported");
+                    }
+                    if (query?.providerOptions !== undefined) {
+                        if (!query.providerOptions || typeof query.providerOptions !== "object" || Array.isArray(query.providerOptions)) {
+                            throw new Error("Tangle environment list providerOptions must be a JSON object");
+                        }
+                        assertBoundedJson(query.providerOptions);
+                    }
+                    if (query?.metadata !== undefined) {
+                        if (!query.metadata || typeof query.metadata !== "object" || Array.isArray(query.metadata)) {
+                            throw new Error("Tangle environment query metadata must be a JSON object");
+                        }
+                        assertBoundedJson(query.metadata);
+                    }
+                    const boxes = await awaitWithSignal(options.client.list?.(operation?.signal ? { signal: operation.signal } : undefined), operation?.signal);
+                    if (!Array.isArray(boxes) || boxes.length > MAX_LIST_RESULTS) {
+                        throw new Error("Tangle environment list exceeded its result bound");
+                    }
+                    const summaries = (boxes ?? []).filter((box) => {
+                        boundedIdentifier(box.id, "Tangle environment id");
+                        if (box.name !== undefined)
+                            boundedString(box.name, "Tangle environment name");
+                        if (box.metadata !== undefined) {
+                            if (!box.metadata || typeof box.metadata !== "object" || Array.isArray(box.metadata)) {
+                                throw new Error("Tangle environment metadata must be a JSON object");
+                            }
+                            assertBoundedJson(box.metadata);
+                        }
+                        const nameMatches = query?.name === undefined || box.name === query.name;
+                        const metadataMatches = query?.metadata === undefined ||
+                            Object.entries(query.metadata).every(([key, value]) => Object.hasOwn(box.metadata ?? {}, key) && JSON.stringify(box.metadata?.[key]) === JSON.stringify(value));
+                        return nameMatches && metadataMatches;
+                    }).map((box) => ({
+                        id: boundedIdentifier(box.id, "Tangle environment id"),
+                        provider: providerName,
+                        ...(box.name ? { name: box.name } : {}),
+                        status: statusFromUnknown(box.status),
+                        ...(box.metadata ? { metadata: box.metadata } : {}),
+                    }));
+                    operation?.signal?.throwIfAborted();
+                    return summaries;
+                },
+            }
+            : {}),
+    };
+}
+function assertProviderOperationOptions(options, label) {
+    if (options === undefined)
+        return;
+    if (!options || typeof options !== "object" || Array.isArray(options)) {
+        throw new Error(`${label} options must be an object`);
+    }
+    for (const key of Object.keys(options)) {
+        if (key !== "signal")
+            throw new Error(`${label} options contain unsupported fields`);
+    }
+}
+function assertEnvironmentQuery(query) {
+    if (query === undefined)
+        return;
+    if (!query || typeof query !== "object" || Array.isArray(query)) {
+        throw new Error("Tangle environment query must be an object");
+    }
+    const keys = new Set(Object.keys(query));
+    for (const key of ["name", "metadata", "providerOptions"])
+        keys.delete(key);
+    if (keys.size > 0)
+        throw new Error("Tangle environment query contains unsupported fields");
+}

package/dist/tangle-result-values.d.ts

@@ -0,0 +1,5 @@
+import type { ExecResult as SandboxExecResult } from "@tangle-network/sandbox";
+import type { ExecResult } from "@tangle-network/agent-interface/environment-provider";
+import type { TokenUsage } from "@tangle-network/agent-interface";
+export declare function execResultFromSandboxExecResult(result: SandboxExecResult | undefined): ExecResult;
+export declare function tokenUsageFromData(data: Record<string, unknown>): TokenUsage | undefined;

package/dist/tangle-result-values.js

@@ -0,0 +1,94 @@
+import { assertBoundedJson, boundedString } from "./tangle-contract-safety.js";
+export function execResultFromSandboxExecResult(result) {
+    if (!result || typeof result !== "object") {
+        throw new Error("Tangle Sandbox exec returned no result");
+    }
+    const record = result;
+    assertBoundedJson(record);
+    if (typeof record.exitCode !== "number" ||
+        !Number.isSafeInteger(record.exitCode)) {
+        throw new Error("Tangle Sandbox exec returned an invalid exit code");
+    }
+    if (typeof record.stdout !== "string" || typeof record.stderr !== "string") {
+        throw new Error("Tangle Sandbox exec returned invalid output streams");
+    }
+    return {
+        exitCode: record.exitCode,
+        stdout: boundedString(record.stdout, "Tangle exec stdout"),
+        stderr: boundedString(record.stderr, "Tangle exec stderr"),
+    };
+}
+export function tokenUsageFromData(data) {
+    assertBoundedJson(data);
+    if (data.usage !== undefined &&
+        (!data.usage || typeof data.usage !== "object" || Array.isArray(data.usage))) {
+        throw new Error("Tangle usage must be an object");
+    }
+    if (data.tokenUsage !== undefined &&
+        (!data.tokenUsage ||
+            typeof data.tokenUsage !== "object" ||
+            Array.isArray(data.tokenUsage))) {
+        throw new Error("Tangle token usage must be an object");
+    }
+    // Only an explicit usage object counts. Scanning the raw event body turned
+    // any field named like a token count into a reported total, including on
+    // events that carry no usage at all.
+    const usageRecord = data.usage && typeof data.usage === "object"
+        ? data.usage
+        : data.tokenUsage && typeof data.tokenUsage === "object"
+            ? data.tokenUsage
+            : undefined;
+    if (usageRecord === undefined)
+        return undefined;
+    assertBoundedJson(usageRecord);
+    const inputTokens = firstValidatedNumber(usageRecord, ["inputTokens", "tokensIn", "prompt_tokens"], "input token count", true);
+    const outputTokens = firstValidatedNumber(usageRecord, ["outputTokens", "tokensOut", "completion_tokens"], "output token count", true);
+    const totalTokens = firstValidatedNumber(usageRecord, ["totalTokens", "tokensTotal", "total_tokens"], "total token count", true);
+    const cacheReadInputTokens = firstValidatedNumber(usageRecord, ["cacheReadInputTokens", "cacheReadTokens", "cache_read_input_tokens"], "cache-read token count", true);
+    const cacheCreationInputTokens = firstValidatedNumber(usageRecord, [
+        "cacheCreationInputTokens",
+        "cacheWriteInputTokens",
+        "cacheCreationTokens",
+        "cache_creation_input_tokens",
+    ], "cache-creation token count", true);
+    const reasoningTokens = firstValidatedNumber(usageRecord, ["reasoningTokens", "reasoning_tokens"], "reasoning token count", true);
+    const nestedCost = firstValidatedNumber(usageRecord, ["cost", "costUsd", "totalCostUsd"], "usage cost", false);
+    const topLevelCost = firstValidatedNumber(data, ["costUsd", "totalCostUsd"], "result cost", false);
+    const cost = nestedCost ?? topLevelCost;
+    // `TokenUsage` cannot express "not reported", so a usage record is only
+    // emitted when both counts were actually measured. Emitting a cost beside
+    // two zeroes published an unmeasured total as a measured one.
+    if (inputTokens === undefined || outputTokens === undefined)
+        return undefined;
+    return {
+        inputTokens,
+        outputTokens,
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+        ...(cacheReadInputTokens !== undefined
+            ? { cacheReadInputTokens }
+            : {}),
+        ...(cacheCreationInputTokens !== undefined
+            ? { cacheCreationInputTokens }
+            : {}),
+        ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+        ...(cost !== undefined ? { cost } : {}),
+    };
+}
+function firstValidatedNumber(record, fields, label, integer) {
+    let selected;
+    for (const field of fields) {
+        if (!Object.hasOwn(record, field))
+            continue;
+        const value = record[field];
+        if (value === undefined)
+            continue;
+        if (typeof value !== "number" ||
+            !Number.isFinite(value) ||
+            value < 0 ||
+            (integer && !Number.isSafeInteger(value))) {
+            throw new Error(`Tangle ${label} is invalid`);
+        }
+        selected ??= value;
+    }
+    return selected;
+}

package/dist/tangle-session-control.d.ts

@@ -0,0 +1,7 @@
+import type { AgentRunControlRef } from "@tangle-network/agent-interface";
+import type { AgentSessionRef } from "@tangle-network/agent-interface/environment-provider";
+export declare function sessionRefFromSandboxDispatch(dispatched: unknown, providerName: string, environmentId: string, expectedExecutionId: string | undefined, requestDigest?: `sha256:${string}` | undefined, expectedSessionId?: string | undefined): AgentSessionRef;
+export declare function retainedSessionControlRef(sessionId: string, executionId: string, provider: string, environmentId: string, requestDigest?: `sha256:${string}`): AgentRunControlRef;
+export declare function sessionPromptExecutionId(provider: string, environmentId: string, sessionId: string, turnId: string | undefined): string;
+export declare function sameRunControlRef(left: AgentRunControlRef, right: AgentRunControlRef): boolean;
+export declare function resolveRetainedSessionControlRef(candidate: AgentRunControlRef | undefined, sessionId: string, provider: string, environmentId: string): AgentRunControlRef | undefined;

package/dist/tangle-session-control.js

@@ -0,0 +1,89 @@
+import { createHash, randomUUID } from "node:crypto";
+import { AgentExactRunControlRefSchema, canonicalCandidateDigest, } from "@tangle-network/agent-interface";
+import { nonEmptyString } from "./tangle-environment-values.js";
+import { assertBoundedJson, boundedIdentifier, } from "./tangle-contract-safety.js";
+export function sessionRefFromSandboxDispatch(dispatched, providerName, environmentId, expectedExecutionId, requestDigest = undefined, expectedSessionId = undefined) {
+    const record = dispatched && typeof dispatched === "object" && !Array.isArray(dispatched)
+        ? dispatched
+        : undefined;
+    if (record)
+        assertBoundedJson(record);
+    const id = record?.sessionId ?? record?.id;
+    if (!record || typeof id !== "string") {
+        throw new Error("sandbox dispatch returned no session id");
+    }
+    boundedIdentifier(id, "Tangle dispatched session id");
+    if (expectedSessionId !== undefined && id !== expectedSessionId) {
+        throw new Error("sandbox dispatch returned a session id different from the requested session");
+    }
+    const executionId = nonEmptyString(record.executionId);
+    if (executionId === undefined) {
+        throw new Error("sandbox dispatch returned no exact execution id for durable replay");
+    }
+    if (expectedExecutionId !== undefined &&
+        executionId !== expectedExecutionId) {
+        throw new Error("sandbox dispatch returned an execution id different from the requested run");
+    }
+    boundedIdentifier(executionId, "Tangle dispatched execution id");
+    if (record.status !== undefined && typeof record.status !== "string") {
+        throw new Error("sandbox dispatch returned an invalid status");
+    }
+    if (record.alreadyExisted !== undefined && typeof record.alreadyExisted !== "boolean") {
+        throw new Error("sandbox dispatch returned an invalid alreadyExisted flag");
+    }
+    if (record.dispatched !== undefined && typeof record.dispatched !== "boolean") {
+        throw new Error("sandbox dispatch returned an invalid dispatched flag");
+    }
+    return {
+        id,
+        provider: providerName,
+        controlRef: retainedSessionControlRef(id, executionId, providerName, environmentId, requestDigest ??
+            canonicalCandidateDigest({ provider: providerName, environmentId, id, executionId })),
+        metadata: {
+            ...(record.status ? { status: record.status } : {}),
+            ...(record.alreadyExisted !== undefined ? { alreadyExisted: record.alreadyExisted } : {}),
+            ...(record.dispatched !== undefined ? { dispatched: record.dispatched } : {}),
+        },
+    };
+}
+export function retainedSessionControlRef(sessionId, executionId, provider, environmentId, requestDigest) {
+    return AgentExactRunControlRefSchema.parse({
+        runId: executionId,
+        provider,
+        environmentId,
+        sessionId,
+        executionId,
+        requestDigest: requestDigest ??
+            canonicalCandidateDigest({ provider, environmentId, sessionId, executionId }),
+    });
+}
+export function sessionPromptExecutionId(provider, environmentId, sessionId, turnId) {
+    if (turnId === undefined)
+        return randomUUID();
+    const digest = createHash("sha256")
+        .update(`${provider}\0${environmentId}\0${sessionId}\0${turnId}`)
+        .digest("hex");
+    return `session-turn-${digest}`;
+}
+export function sameRunControlRef(left, right) {
+    return (left.runId === right.runId &&
+        left.provider === right.provider &&
+        left.environmentId === right.environmentId &&
+        left.sessionId === right.sessionId &&
+        left.executionId === right.executionId &&
+        left.requestDigest === right.requestDigest);
+}
+export function resolveRetainedSessionControlRef(candidate, sessionId, provider, environmentId) {
+    if (candidate === undefined)
+        return undefined;
+    const controlRef = AgentExactRunControlRefSchema.parse(candidate);
+    if (controlRef.provider !== provider ||
+        controlRef.environmentId !== environmentId ||
+        controlRef.sessionId !== sessionId) {
+        throw new Error("Tangle control reference does not match this session");
+    }
+    if (controlRef.runId !== controlRef.executionId) {
+        throw new Error("Tangle session control reference requires runId to equal executionId");
+    }
+    return controlRef;
+}

package/dist/tangle-types.d.ts

@@ -0,0 +1,141 @@
+import type { BackendType, CreateSandboxOptions, ExecResult as SandboxExecResult, PromptOptions, PromptResult, SandboxEvent } from "@tangle-network/sandbox";
+import type { InputPart } from "@tangle-network/agent-interface";
+import type { AgentEnvironmentCapabilities, AgentEnvironmentProvider, CreateAgentEnvironmentInput } from "@tangle-network/agent-interface/environment-provider";
+export interface TangleExactProcessOptions {
+    teamId?: string;
+}
+export interface SandboxClientLike {
+    create(options?: CreateSandboxOptions, requestOptions?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<SandboxInstanceLike>;
+    get?(id: string, requestOptions?: {
+        signal?: AbortSignal;
+    }): Promise<SandboxInstanceLike | null>;
+    list?(options?: {
+        scope?: string;
+        limit?: number;
+        offset?: number;
+        signal?: AbortSignal;
+    }): Promise<SandboxInstanceLike[]>;
+    describePlacement?(box: SandboxInstanceLike): unknown;
+}
+export interface SandboxProcessStatusLike {
+    pid: number;
+    running: boolean;
+    exitCode: number;
+    exitSignal?: string;
+}
+export interface SandboxProcessLike {
+    readonly pid: number;
+    status(): Promise<SandboxProcessStatusLike>;
+    wait(): Promise<number>;
+    kill(signal?: "SIGKILL", options?: {
+        tree?: boolean;
+    }): Promise<void>;
+    stdout(): AsyncIterable<string>;
+    stderr(): AsyncIterable<string>;
+}
+export interface SandboxProcessManagerLike {
+    list(): Promise<SandboxProcessStatusLike[]>;
+    get(pid: number): Promise<SandboxProcessLike | null>;
+    spawnExact(executable: string, args: readonly string[], options?: {
+        cwd?: string;
+        env?: Record<string, string>;
+        inheritEnv?: boolean;
+        stdin?: string;
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<SandboxProcessLike>;
+}
+export interface SandboxInstanceLike {
+    id: string;
+    name?: string;
+    status?: unknown;
+    metadata?: Record<string, unknown>;
+    streamPrompt(message: string | InputPart[], options?: PromptOptions): AsyncIterable<SandboxEvent>;
+    prompt?(message: string | InputPart[], options?: PromptOptions): Promise<PromptResult>;
+    dispatchPrompt?(message: string | InputPart[], options?: PromptOptions): Promise<unknown>;
+    session?(id: string, options?: {
+        signal?: AbortSignal;
+    }): SandboxSessionLike;
+    read?(path: string, options?: {
+        sessionId?: string;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    write?(path: string, content: string, options?: {
+        sessionId?: string;
+        signal?: AbortSignal;
+    }): Promise<unknown>;
+    exec?(command: string, options?: unknown): Promise<SandboxExecResult>;
+    fs?: {
+        supportsWriteMode?: true;
+        stat(path: string): Promise<{
+            size: number;
+            isFile: boolean;
+        }>;
+        readBatch(paths: string[], options?: {
+            encoding?: "utf8" | "base64";
+        }): Promise<{
+            files: Array<{
+                path: string;
+                content: string;
+                encoding: "utf8" | "base64";
+                size: number;
+            }>;
+            errors: Array<{
+                path: string;
+                error: string;
+                code?: string;
+            }>;
+        }>;
+        write(path: string, content: string, options: {
+            encoding: "base64";
+            mode: number;
+        }): Promise<unknown>;
+    };
+    process?: SandboxProcessManagerLike;
+    checkpoint?(options?: {
+        signal?: AbortSignal;
+    } & Record<string, unknown>): Promise<unknown>;
+    fork?(checkpointId: string, options?: {
+        signal?: AbortSignal;
+    } & Record<string, unknown>): Promise<SandboxInstanceLike>;
+    refresh?(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    delete?(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+export interface SandboxSessionLike {
+    readonly id: string;
+    status(options?: {
+        signal?: AbortSignal;
+    }): Promise<unknown | null>;
+    events(options?: {
+        since?: string;
+        executionId?: string;
+        signal?: AbortSignal;
+    }): AsyncIterable<SandboxEvent>;
+    result(options?: {
+        executionId?: string;
+        signal?: AbortSignal;
+    }): Promise<PromptResult>;
+    prompt(message: string | InputPart[], options?: PromptOptions): Promise<PromptResult>;
+    interrupt(options?: {
+        executionId?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        cancelled: boolean;
+    }>;
+}
+export interface TangleProviderOptions {
+    client: SandboxClientLike;
+    name?: string;
+    defaultBackend?: BackendType;
+    capabilities?: AgentEnvironmentCapabilities | (() => AgentEnvironmentCapabilities | Promise<AgentEnvironmentCapabilities>);
+    validateProfile?: AgentEnvironmentProvider["validateProfile"];
+    mapCreateInput?: (input: CreateAgentEnvironmentInput) => CreateSandboxOptions;
+    exactProcess?: TangleExactProcessOptions;
+}

package/dist/tangle-types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-provider-tangle",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "AgentEnvironmentProvider adapter for Tangle sandboxes",
   "type": "module",
   "license": "MIT",
@@ -27,11 +27,47 @@
     "dist/index.js",
     "dist/exact-process.d.ts",
     "dist/exact-process.js",
+    "dist/tangle-exact-process-environment.d.ts",
+    "dist/tangle-exact-process-environment.js",
+    "dist/tangle-contract-safety.d.ts",
+    "dist/tangle-contract-safety.js",
+    "dist/tangle-exact-process-runtime.d.ts",
+    "dist/tangle-exact-process-runtime.js",
+    "dist/tangle-exact-process-validation.d.ts",
+    "dist/tangle-exact-process-validation.js",
+    "dist/tangle-capabilities.d.ts",
+    "dist/tangle-capabilities.js",
+    "dist/tangle-create-options.d.ts",
+    "dist/tangle-create-options.js",
+    "dist/tangle-environment-values.d.ts",
+    "dist/tangle-environment-values.js",
+    "dist/tangle-environment.d.ts",
+    "dist/tangle-environment.js",
+    "dist/tangle-environment-dispatch.d.ts",
+    "dist/tangle-environment-dispatch.js",
+    "dist/tangle-environment-session.d.ts",
+    "dist/tangle-environment-session.js",
+    "dist/tangle-environment-control.d.ts",
+    "dist/tangle-environment-control.js",
+    "dist/tangle-environment-validation.d.ts",
+    "dist/tangle-environment-validation.js",
+    "dist/tangle-events.d.ts",
+    "dist/tangle-events.js",
+    "dist/tangle-prompt.d.ts",
+    "dist/tangle-prompt.js",
+    "dist/tangle-provider.d.ts",
+    "dist/tangle-provider.js",
+    "dist/tangle-result-values.d.ts",
+    "dist/tangle-result-values.js",
+    "dist/tangle-session-control.d.ts",
+    "dist/tangle-session-control.js",
+    "dist/tangle-types.d.ts",
+    "dist/tangle-types.js",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@tangle-network/agent-interface": "0.45.0"
+    "@tangle-network/agent-interface": "0.46.1"
   },
   "peerDependencies": {
     "@tangle-network/sandbox": ">=0.17.0 <1.0.0"
@@ -46,7 +82,7 @@
     "@types/node": "25.6.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5",
-    "@tangle-network/agent-provider-testkit": "0.5.5"
+    "@tangle-network/agent-provider-testkit": "0.6.1"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",