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

package/dist/index.js

@@ -1,687 +1,3 @@
-import { createHash, randomUUID } from "node:crypto";
-import { AgentEnvironmentCapabilitiesSchema, } from "@tangle-network/agent-interface/environment-provider";
-import { AgentRunControlRefSchema, ContextTransferReceiptSchema, harnessSystemPromptIntents, } from "@tangle-network/agent-interface";
-import { createTangleExactProcessProvider, } from "./exact-process.js";
-export function createTangleProvider(options) {
-    const providerName = options.name ?? "tangle-sandbox";
-    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");
-        }
-        return AgentEnvironmentCapabilitiesSchema.parse(exactProcess
-            ? {
-                ...configured,
-                exactProcess: { egress: ["blocked", "strict"] },
-            }
-            : configured);
-    };
-    return {
-        name: providerName,
-        ...(exactProcess ? { exactProcess } : {}),
-        capabilities: resolveCapabilities,
-        ...(options.validateProfile ? { validateProfile: options.validateProfile } : {}),
-        async create(input) {
-            const capabilities = await resolveCapabilities();
-            const createOptions = options.mapCreateInput?.(input) ??
-                sandboxOptionsFromCreateInput(input, options.defaultBackend ?? "opencode");
-            const box = await options.client.create(createOptions, input.signal ? { signal: input.signal } : undefined);
-            return sandboxInstanceAsEnvironment(box, providerName, options.client, capabilities);
-        },
-        ...(options.client.get
-            ? {
-                async get(id) {
-                    const box = await options.client.get?.(id);
-                    return box
-                        ? sandboxInstanceAsEnvironment(box, providerName, options.client, await resolveCapabilities())
-                        : null;
-                },
-            }
-            : {}),
-        ...(options.client.list
-            ? {
-                async list(query) {
-                    const boxes = await options.client.list?.(query?.providerOptions);
-                    return (boxes ?? []).map((box) => ({
-                        id: String(box.id),
-                        provider: providerName,
-                        ...(box.name ? { name: box.name } : {}),
-                        status: statusFromUnknown(box.status),
-                        ...(box.metadata ? { metadata: box.metadata } : {}),
-                    }));
-                },
-            }
-            : {}),
-    };
-}
-function sandboxInstanceAsEnvironment(box, providerName, client, capabilities) {
-    return {
-        id: String(box.id),
-        provider: providerName,
-        ...(box.name ? { name: box.name } : {}),
-        async status() {
-            await box.refresh?.();
-            return statusFromUnknown(box.status);
-        },
-        async *stream(input) {
-            const expectedExecutionId = executionIdFromTurnInput(input);
-            const expectedSessionId = input.sessionId ?? input.controlRef?.sessionId;
-            for await (const event of box.streamPrompt(promptFromTurnInput(input), promptOptionsFromTurnInput(input, {
-                provider: providerName,
-                environmentId: String(box.id),
-            }))) {
-                yield environmentEventFromSandboxEvent(event, {
-                    executionId: expectedExecutionId,
-                    sessionId: expectedSessionId,
-                });
-            }
-        },
-        ...(capabilities.streaming.detach && box.dispatchPrompt
-            ? {
-                async dispatch(input) {
-                    const dispatched = await box.dispatchPrompt?.(promptFromTurnInput(input), promptOptionsFromTurnInput(input, {
-                        provider: providerName,
-                        environmentId: String(box.id),
-                    }));
-                    return sessionRefFromSandboxDispatch(dispatched, providerName, String(box.id), executionIdFromTurnInput(input));
-                },
-            }
-            : {}),
-        ...((capabilities.sessions.continue ||
-            capabilities.streaming.replay ||
-            capabilities.streaming.detach) &&
-            box.session
-            ? {
-                session(id, options) {
-                    const session = box.session?.(id);
-                    if (!session)
-                        throw new Error("sandbox session(id) returned undefined");
-                    return sandboxSessionAsAgentSession(session, resolveRetainedSessionControlRef(options?.controlRef, session.id, providerName, String(box.id)), providerName, String(box.id));
-                },
-            }
-            : {}),
-        ...(capabilities.workspace.read && box.read
-            ? { read: box.read.bind(box) }
-            : {}),
-        ...(capabilities.workspace.write && box.write
-            ? {
-                async write(path, content) {
-                    await box.write?.(path, content);
-                },
-            }
-            : {}),
-        ...(capabilities.workspace.exec && box.exec
-            ? {
-                async exec(command, options) {
-                    return execResultFromSandboxExecResult(await box.exec?.(command, options));
-                },
-            }
-            : {}),
-        ...(capabilities.branching.checkpoint && box.checkpoint
-            ? {
-                async checkpoint(options) {
-                    const result = await box.checkpoint?.(options);
-                    return { id: checkpointIdFromResult(result), provider: providerName };
-                },
-            }
-            : {}),
-        ...(capabilities.branching.fork && box.fork
-            ? {
-                async fork(checkpoint, options) {
-                    const forked = await box.fork?.(checkpoint.id, options);
-                    if (!forked)
-                        throw new Error("sandbox fork returned no environment");
-                    return sandboxInstanceAsEnvironment(forked, providerName, client, capabilities);
-                },
-            }
-            : {}),
-        ...(capabilities.placement
-            ? {
-                async placement() {
-                    return placementInfoFromLoopPlacement(client.describePlacement?.(box), box);
-                },
-            }
-            : {}),
-        async refresh() {
-            await box.refresh?.();
-        },
-        async destroy() {
-            await box.delete?.();
-        },
-    };
-}
-function sandboxSessionAsAgentSession(session, controlRef, provider, environmentId) {
-    let activeControlRef = controlRef;
-    return {
-        id: session.id,
-        get controlRef() {
-            return activeControlRef;
-        },
-        async status() {
-            const status = await session.status();
-            if (!status)
-                return null;
-            return sessionStatusFromUnknown(status.status);
-        },
-        async *events(options) {
-            if (options?.executionId !== undefined &&
-                activeControlRef?.executionId !== undefined &&
-                options.executionId !== activeControlRef.executionId) {
-                throw new Error("Tangle replay executionId conflicts with the control reference");
-            }
-            const executionId = activeControlRef?.executionId ?? options?.executionId;
-            if (options?.since !== undefined && executionId === undefined) {
-                throw new Error("Tangle cursor replay requires an exact executionId from its control reference");
-            }
-            const seenEventIds = new Set();
-            for await (const event of session.events({
-                ...(options?.since !== undefined ? { since: options.since } : {}),
-                ...(executionId !== undefined ? { executionId } : {}),
-                ...(options?.signal ? { signal: options.signal } : {}),
-            })) {
-                if (options?.since !== undefined && event.id === options.since)
-                    continue;
-                const converted = environmentEventFromSandboxEvent(event, {
-                    executionId,
-                    sessionId: session.id,
-                });
-                if (executionId !== undefined && converted.id === undefined) {
-                    throw new Error("Tangle exact session replay received an event without a stable id");
-                }
-                if (converted.id !== undefined) {
-                    if (seenEventIds.has(converted.id)) {
-                        throw new Error(`Tangle session replay repeated event id ${converted.id}`);
-                    }
-                    seenEventIds.add(converted.id);
-                }
-                yield converted;
-            }
-        },
-        async result() {
-            const expectedExecutionId = activeControlRef?.executionId;
-            if (expectedExecutionId === undefined) {
-                throw new Error("Tangle session result requires an exact executionId from its control reference");
-            }
-            const result = await session.result({ executionId: expectedExecutionId });
-            const resultRecord = validatedSandboxPromptResult(result);
-            if (resultRecord.executionId !== expectedExecutionId) {
-                throw new Error("Tangle session result did not confirm its exact executionId");
-            }
-            return agentTurnResultFromPromptRecord(resultRecord);
-        },
-        async prompt(input) {
-            if (input.sessionId !== undefined && input.sessionId !== session.id) {
-                throw new Error("Tangle sessionId conflicts with this session");
-            }
-            const requestedControlRef = resolveRetainedSessionControlRef(input.controlRef, session.id, provider, environmentId);
-            if (activeControlRef !== undefined &&
-                requestedControlRef !== undefined &&
-                !sameRunControlRef(activeControlRef, requestedControlRef)) {
-                throw new Error("Tangle prompt control reference conflicts with this session");
-            }
-            const sourceControlRef = requestedControlRef ?? activeControlRef;
-            const replay = input.lastEventId !== undefined;
-            if (replay &&
-                sourceControlRef?.executionId !== undefined &&
-                input.executionId !== undefined &&
-                input.executionId !== sourceControlRef.executionId) {
-                throw new Error("Tangle replay executionId conflicts with the control reference");
-            }
-            const executionId = replay
-                ? input.executionId ?? sourceControlRef?.executionId
-                : input.executionId ??
-                    sessionPromptExecutionId(provider, environmentId, session.id, input.turnId);
-            if (executionId === undefined) {
-                throw new Error("Tangle session replay requires the exact executionId from its control reference");
-            }
-            const result = await session.prompt(promptFromTurnInput(input), promptOptionsFromTurnInput({
-                ...input,
-                sessionId: session.id,
-                executionId,
-                controlRef: undefined,
-            }, {
-                provider,
-                environmentId,
-                sessionId: session.id,
-            }));
-            const resultRecord = validatedSandboxPromptResult(result);
-            if (resultRecord.executionId !== executionId) {
-                throw new Error("Tangle session prompt did not confirm its exact executionId");
-            }
-            if (replay) {
-                activeControlRef =
-                    sourceControlRef ??
-                        retainedSessionControlRef(session.id, executionId, provider, environmentId);
-                return agentTurnResultFromPromptRecord(resultRecord);
-            }
-            activeControlRef = retainedSessionControlRef(session.id, executionId, provider, environmentId);
-            return agentTurnResultFromPromptRecord(resultRecord);
-        },
-        async cancel() {
-            const executionId = activeControlRef?.executionId;
-            if (executionId === undefined) {
-                throw new Error("Tangle session cancellation requires an exact executionId from its control reference");
-            }
-            await session.interrupt({ executionId });
-        },
-    };
-}
-function sandboxOptionsFromCreateInput(input, defaultBackend) {
-    const workspace = input.workspace ?? {};
-    if (workspace.environment !== undefined && workspace.image !== undefined) {
-        throw new Error("Tangle workspace cannot specify both environment and image");
-    }
-    const environment = workspace.image ?? workspace.environment;
-    const providerOptions = input.providerOptions?.sandboxCreateOptions;
-    const base = providerOptions && typeof providerOptions === "object"
-        ? { ...providerOptions }
-        : {};
-    return {
-        ...base,
-        ...(environment !== undefined ? { environment } : {}),
-        ...(workspace.repoUrl ? { git: { url: workspace.repoUrl, ref: workspace.gitRef } } : {}),
-        ...(input.resources ? { resources: input.resources } : {}),
-        ...(input.env ? { env: input.env } : {}),
-        ...(Array.isArray(input.secrets) ? { secrets: input.secrets } : {}),
-        ...(input.metadata ? { metadata: input.metadata } : {}),
-        ...(input.name ? { name: input.name } : {}),
-        ...(input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {}),
-        backend: {
-            ...(base.backend ?? {}),
-            type: (input.backend ?? defaultBackend),
-            profile: inlineAgentProfile(input.profile),
-        },
-    };
-}
-function inlineAgentProfile(profile) {
-    if (typeof profile === "string") {
-        throw new Error("Tangle provider requires an inline AgentProfile, not a profile reference");
-    }
-    return profile;
-}
-function environmentEventFromSandboxEvent(event, expected = {}) {
-    if (!event || typeof event !== "object") {
-        throw new Error("Tangle Sandbox emitted a non-object event");
-    }
-    const record = event;
-    if (typeof record.type !== "string" || record.type.length === 0) {
-        throw new Error("Tangle Sandbox event omitted its type");
-    }
-    if (!record.data ||
-        typeof record.data !== "object" ||
-        Array.isArray(record.data)) {
-        throw new Error("Tangle Sandbox event omitted its object data");
-    }
-    if (record.id !== undefined &&
-        (typeof record.id !== "string" || record.id.length === 0)) {
-        throw new Error("Tangle Sandbox event contained an invalid event id");
-    }
-    const data = record.data;
-    const eventExecutionId = optionalNonEmptyString(data.executionId, "Tangle Sandbox event executionId");
-    const eventSessionId = optionalNonEmptyString(data.sessionId, "Tangle Sandbox event sessionId");
-    // Sandbox binds the stream with session.events({ executionId }). Individual
-    // event variants do not all repeat that selector, so validate IDs when present.
-    if (expected.executionId !== undefined &&
-        eventExecutionId !== undefined &&
-        eventExecutionId !== expected.executionId) {
-        throw new Error("Tangle exact session event identified a different executionId");
-    }
-    if (expected.sessionId !== undefined &&
-        eventSessionId !== undefined &&
-        eventSessionId !== expected.sessionId) {
-        throw new Error("Tangle exact session event identified a different sessionId");
-    }
-    return {
-        type: record.type,
-        data,
-        ...(typeof record.id === "string" ? { id: record.id } : {}),
-        usage: tokenUsageFromData(data),
-        providerEvent: event,
-    };
-}
-function promptFromTurnInput(input) {
-    if (input.parts)
-        return input.parts;
-    return input.prompt ?? "";
-}
-function executionIdFromTurnInput(input) {
-    return input.executionId ?? input.controlRef?.executionId;
-}
-function promptOptionsFromTurnInput(input, target) {
-    if (input.contextTransfer !== undefined) {
-        throw new Error("Tangle provider does not yet support portable context transfer");
-    }
-    if (input.nativeContinuation !== undefined) {
-        throw new Error("Tangle provider does not yet support verified native continuation");
-    }
-    const controlRef = input.controlRef
-        ? AgentRunControlRefSchema.parse(input.controlRef)
-        : undefined;
-    if (controlRef) {
-        if (controlRef.provider !== target.provider ||
-            controlRef.environmentId !== target.environmentId ||
-            (target.sessionId !== undefined &&
-                controlRef.sessionId !== target.sessionId)) {
-            throw new Error("Tangle control reference does not match this target");
-        }
-        if (controlRef.sessionId === undefined || controlRef.executionId === undefined) {
-            throw new Error("Tangle control reference requires exact sessionId and executionId");
-        }
-        if (controlRef.runId !== controlRef.executionId) {
-            throw new Error("Tangle control reference requires runId to equal executionId");
-        }
-        if (input.sessionId !== undefined &&
-            input.sessionId !== controlRef.sessionId) {
-            throw new Error("Tangle sessionId conflicts with the control reference");
-        }
-        if (input.executionId !== undefined &&
-            input.executionId !== controlRef.executionId) {
-            throw new Error("Tangle executionId conflicts with the control reference");
-        }
-    }
-    const sessionId = input.sessionId ?? controlRef?.sessionId;
-    const executionId = input.executionId ?? controlRef?.executionId;
-    return {
-        ...(sessionId ? { sessionId } : {}),
-        ...(input.model ? { model: input.model } : {}),
-        ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs } : {}),
-        ...(input.context ? { context: input.context } : {}),
-        ...(input.signal ? { signal: input.signal } : {}),
-        ...(executionId ? { executionId } : {}),
-        ...(input.lastEventId ? { lastEventId: input.lastEventId } : {}),
-        ...(input.turnId ? { turnId: input.turnId } : {}),
-        ...(input.detach !== undefined ? { detach: input.detach } : {}),
-    };
-}
-function validatedSandboxPromptResult(result) {
-    if (!result || typeof result !== "object" || Array.isArray(result)) {
-        throw new Error("Tangle prompt returned no result object");
-    }
-    const record = result;
-    if (typeof record.success !== "boolean") {
-        throw new Error("Tangle prompt result omitted its success status");
-    }
-    const statuses = new Set([
-        "success",
-        "failed",
-        "blocked_on_approval",
-        "awaiting_question",
-        "awaiting_plan_decision",
-    ]);
-    if (typeof record.status !== "string" ||
-        !statuses.has(record.status)) {
-        throw new Error("Tangle prompt result contained an invalid run status");
-    }
-    if (record.success !== (record.status === "success")) {
-        throw new Error("Tangle prompt result success flag conflicts with its run status");
-    }
-    if (typeof record.durationMs !== "number" ||
-        !Number.isFinite(record.durationMs) ||
-        record.durationMs < 0) {
-        throw new Error("Tangle prompt result contained an invalid duration");
-    }
-    for (const field of [
-        "executionId",
-        "response",
-        "text",
-        "finalText",
-        "error",
-        "errorCode",
-        "traceId",
-    ]) {
-        if (record[field] !== undefined && typeof record[field] !== "string") {
-            throw new Error(`Tangle prompt result contained an invalid ${field}`);
-        }
-    }
-    if (record.executionId === "") {
-        throw new Error("Tangle prompt result contained an empty executionId");
-    }
-    tokenUsageFromData(record);
-    return record;
-}
-function agentTurnResultFromPromptRecord(record) {
-    const text = typeof record.response === "string"
-        ? record.response
-        : typeof record.text === "string"
-            ? record.text
-            : typeof record.finalText === "string"
-                ? record.finalText
-                : "";
-    const contextTransferReceipt = ContextTransferReceiptSchema.safeParse(record.contextTransferReceipt);
-    if (record.contextTransferReceipt !== undefined &&
-        !contextTransferReceipt.success) {
-        throw new Error("Tangle prompt result contained an invalid context receipt");
-    }
-    return {
-        text,
-        success: record.success,
-        ...(typeof record.error === "string" ? { error: record.error } : {}),
-        usage: tokenUsageFromData(record),
-        ...(contextTransferReceipt.success
-            ? { contextTransferReceipt: contextTransferReceipt.data }
-            : {}),
-    };
-}
-function sessionRefFromSandboxDispatch(dispatched, providerName, environmentId, expectedExecutionId) {
-    const record = dispatched && typeof dispatched === "object"
-        ? dispatched
-        : undefined;
-    const id = record?.sessionId ?? record?.id;
-    if (typeof id !== "string" || id.length === 0 || !record) {
-        throw new Error("sandbox dispatch returned no session id");
-    }
-    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");
-    }
-    return {
-        id,
-        provider: providerName,
-        controlRef: retainedSessionControlRef(id, executionId, providerName, environmentId),
-        metadata: {
-            ...(record.status ? { status: record.status } : {}),
-            ...(record.alreadyExisted !== undefined ? { alreadyExisted: record.alreadyExisted } : {}),
-            ...(record.dispatched !== undefined ? { dispatched: record.dispatched } : {}),
-        },
-    };
-}
-function retainedSessionControlRef(sessionId, executionId, provider, environmentId) {
-    return AgentRunControlRefSchema.parse({
-        runId: executionId,
-        provider,
-        environmentId,
-        sessionId,
-        executionId,
-    });
-}
-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}`;
-}
-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);
-}
-function resolveRetainedSessionControlRef(candidate, sessionId, provider, environmentId) {
-    if (candidate === undefined)
-        return undefined;
-    const controlRef = AgentRunControlRefSchema.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.executionId === undefined ||
-        controlRef.runId !== controlRef.executionId) {
-        throw new Error("Tangle session control reference requires runId to equal executionId");
-    }
-    return controlRef;
-}
-function nonEmptyString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function optionalNonEmptyString(value, label) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "string" || value.length === 0) {
-        throw new Error(`${label} must be a non-empty string`);
-    }
-    return value;
-}
-function execResultFromSandboxExecResult(result) {
-    if (!result || typeof result !== "object") {
-        throw new Error("Tangle Sandbox exec returned no result");
-    }
-    const record = result;
-    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: record.stdout,
-        stderr: record.stderr,
-    };
-}
-function checkpointIdFromResult(result) {
-    const record = result && typeof result === "object" ? result : {};
-    const id = record.checkpointId ?? record.id;
-    if (typeof id !== "string" || id.length === 0) {
-        throw new Error("sandbox checkpoint returned no checkpoint id");
-    }
-    return id;
-}
-function placementInfoFromLoopPlacement(placement, box) {
-    if (!placement || typeof placement !== "object")
-        return { kind: "sandbox", sandboxId: String(box.id) };
-    const record = placement;
-    return {
-        kind: record.kind === "fleet" ? "fleet" : "sandbox",
-        sandboxId: typeof record.sandboxId === "string" ? record.sandboxId : String(box.id),
-        ...(typeof record.fleetId === "string" ? { fleetId: record.fleetId } : {}),
-        ...(typeof record.machineId === "string" ? { machineId: record.machineId } : {}),
-    };
-}
-function tokenUsageFromData(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");
-    }
-    const usageRecord = data.usage && typeof data.usage === "object"
-        ? data.usage
-        : data.tokenUsage && typeof data.tokenUsage === "object"
-            ? data.tokenUsage
-            : data;
-    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 nestedCost = firstValidatedNumber(usageRecord, ["cost", "costUsd", "totalCostUsd"], "usage cost", false);
-    const topLevelCost = firstValidatedNumber(data, ["costUsd", "totalCostUsd"], "result cost", false);
-    const cost = nestedCost ?? topLevelCost;
-    if (inputTokens === undefined && outputTokens === undefined && cost === undefined)
-        return undefined;
-    return {
-        inputTokens: inputTokens ?? 0,
-        outputTokens: outputTokens ?? 0,
-        ...(cost !== undefined ? { cost } : {}),
-    };
-}
-function firstValidatedNumber(record, fields, label, integer) {
-    let selected;
-    for (const field of fields) {
-        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;
-}
-function statusFromUnknown(status) {
-    if (status === "pending" || status === "provisioning" || status === "running")
-        return status;
-    if (status === "stopped" || status === "failed" || status === "expired")
-        return status;
-    if (status === "completed" || status === "cancelled")
-        return "stopped";
-    return "unknown";
-}
-function sessionStatusFromUnknown(status) {
-    if (status === "completed" || status === "cancelled")
-        return status;
-    return statusFromUnknown(status);
-}
-/**
- * @param harness The harness the sandbox will materialize the profile with. The prompt intents are
- * that harness's, not this adapter's: forwarding the whole profile on the wire makes both fields
- * *expressible*, but the sandbox's materializer refuses the intent its harness has no control for
- * (opencode has no replacement, codex and gemini no addition). Omit it and both intents declare
- * `false` — an adapter that cannot name its harness cannot promise either one.
- */
-export function defaultTangleSandboxCapabilities(harness) {
-    return {
-        profile: {
-            namedProfiles: true,
-            systemPrompt: harnessSystemPromptIntents(harness),
-            instructions: true,
-            tools: true,
-            permissions: true,
-            mcp: true,
-            subagents: true,
-            resources: {
-                files: true,
-                instructions: true,
-                tools: true,
-                skills: true,
-                agents: true,
-                commands: true,
-            },
-            hooks: true,
-            modes: true,
-            runtimeUpdate: true,
-            validation: true,
-        },
-        streaming: { live: true, replay: true, detach: true, turnIdempotency: true },
-        sessions: { continue: true, list: true, messages: true },
-        workspace: { read: true, write: true, exec: true, git: true, upload: true, download: true },
-        branching: { checkpoint: false, fork: false },
-        placement: true,
-        usage: true,
-        confidential: true,
-    };
-}
+export * from "./tangle-types.js";
+export { createTangleProvider } from "./tangle-provider.js";
+export { defaultTangleSandboxCapabilities } from "./tangle-capabilities.js";