@tangle-network/agent-interface 0.45.0 → 0.46.1

package/dist/index.js

@@ -1,132 +1,17 @@
-/**
- * Agent Interface
- *
- * Shared types and interfaces for SDK provider adapters.
- * This package defines the contract between the sidecar and provider implementations.
- */
-export { AgentEnvironmentCapabilitiesSchema, AgentNativeContextContinuationResultSchema, AgentTurnResultSchema, agentNativeContextContinuationResultMatchesRequest, } from "./environment-provider.js";
+/** Shared types and interfaces for SDK provider adapters. */
+export * from "./parts.js";
+export * from "./stream-events.js";
+export * from "./execution-types.js";
+export * from "./backend-message.js";
+export * from "./provider-config.js";
+export * from "./host-services.js";
+export * from "./mcp.js";
+export * from "./provider-adapter.js";
+export { AgentEnvironmentCapabilitiesSchema, AgentNativeContextContinuationResultSchema, AgentTurnInputSchema, AgentTurnResultSchema, agentNativeContextContinuationResultMatchesRequest, } from "./environment-provider.js";
 export * from "./plan.js";
 export * from "./runtime-control.js";
 export * from "./portable-context.js";
 export * from "./workspace-branching.js";
-/** Helper to check part type */
-export function isTextPart(part) {
-    return part.type === "text";
-}
-export function isToolPart(part) {
-    return part.type === "tool";
-}
-export function isReasoningPart(part) {
-    return part.type === "reasoning";
-}
-export function isFilePart(part) {
-    return part.type === "file";
-}
-export function isSubtaskPart(part) {
-    return part.type === "subtask";
-}
-export function isInputTextPart(part) {
-    return part.type === "text";
-}
-export function isInputFilePart(part) {
-    return part.type === "file";
-}
-export function isInputImagePart(part) {
-    return part.type === "image";
-}
-export function normalizeInputParts(input) {
-    if (Array.isArray(input.parts) && input.parts.length > 0) {
-        return input.parts;
-    }
-    if (typeof input.message === "string" && input.message.length > 0) {
-        return [{ type: "text", text: input.message }];
-    }
-    return [];
-}
-export function renderInputPartsAsText(parts) {
-    const textParts = [];
-    const attachmentRefs = [];
-    for (const part of parts) {
-        if (part.type === "text") {
-            if (part.text)
-                textParts.push(part.text);
-            continue;
-        }
-        const label = part.path ||
-            part.filename ||
-            part.url ||
-            (part.type === "image" ? "image attachment" : "file attachment");
-        attachmentRefs.push(`[${part.type === "image" ? "Image" : "File"}: ${label}]`);
-    }
-    if (attachmentRefs.length === 0) {
-        return textParts.join("\n\n").trim();
-    }
-    const text = textParts.join("\n\n").trim();
-    const attachmentBlock = `Attached files:\n${attachmentRefs.join("\n")}`;
-    return text ? `${text}\n\n${attachmentBlock}` : attachmentBlock;
-}
-export const TANGLE_ROUTER_DEFAULT_ROOT_URL = "https://router.tangle.tools";
-export const TANGLE_ROUTER_DEFAULT_MODEL = "zai/glm-4.7";
-/**
- * Normalizes an OpenAI-compatible base URL for SDKs that append
- * `/chat/completions` to the configured base. Existing `/vN` suffixes are
- * preserved so explicit `/v2` endpoints do not become `/v2/v1`.
- */
-export function normalizeOpenAiCompatibleBaseUrl(baseUrl) {
-    const trimmed = baseUrl.replace(/\/+$/, "");
-    return /\/v\d+$/.test(trimmed) ? trimmed : `${trimmed}/v1`;
-}
-/**
- * Returns the platform model gateway defaults. Env overrides are read here so
- * every harness adapter shares the same dynamic seam.
- */
-export function resolveTangleRouterDefaults(env = process.env) {
-    const rootUrl = env.TANGLE_ROUTER_URL || TANGLE_ROUTER_DEFAULT_ROOT_URL;
-    return {
-        provider: "openai-compat",
-        name: env.TANGLE_ROUTER_PROVIDER_NAME || "Tangle Router",
-        rootUrl,
-        baseUrl: normalizeOpenAiCompatibleBaseUrl(env.TANGLE_ROUTER_BASE_URL || rootUrl),
-        model: env.TANGLE_ROUTER_MODEL || TANGLE_ROUTER_DEFAULT_MODEL,
-        apiKeyEnvVar: env.TANGLE_ROUTER_API_KEY_ENV || "OPENCODE_MODEL_API_KEY",
-    };
-}
-/**
- * Applies gateway defaults to a provider model config. Existing fields win.
- */
-export function withModelGatewayDefaults(model, defaults = resolveTangleRouterDefaults()) {
-    return {
-        ...model,
-        provider: model.provider || defaults.provider,
-        model: model.model || defaults.model,
-        baseUrl: model.baseUrl || defaults.baseUrl,
-    };
-}
-// Canonical and per-harness spellings collapse to these, separator/case-insensitive.
-const nativeWebSearchKeys = new Set(["websearch"]);
-const nativeWebFetchKeys = new Set(["webfetch", "fetch"]);
-/**
- * Map an AgentProfile `tools` map to a {@link NativeWebToolPosture}. Accepts
- * the canonical `web_search`/`web_fetch` as well as each harness's native
- * spelling (`WebSearch`, `webfetch`, …) — keys are normalized by stripping
- * non-alphanumerics and lowercasing, so a single directive works everywhere.
- * Non-boolean and unrelated tool entries are ignored.
- */
-export function resolveNativeWebTools(tools) {
-    if (!tools)
-        return {};
-    const posture = {};
-    for (const [key, value] of Object.entries(tools)) {
-        if (typeof value !== "boolean")
-            continue;
-        const normalized = key.replace(/[^a-z0-9]/gi, "").toLowerCase();
-        if (nativeWebSearchKeys.has(normalized))
-            posture.search = value;
-        else if (nativeWebFetchKeys.has(normalized))
-            posture.fetch = value;
-    }
-    return posture;
-}
 export * from "./interaction.js";
 export * from "./agent-candidate.js";
 export * from "./agent-candidate-schema.js";

package/dist/interaction-answer-validation.d.ts

@@ -0,0 +1,13 @@
+import { type InteractionAnswerSpec } from "./interaction-fields.js";
+import type { InteractionData } from "./interaction-data.js";
+export type InteractionValidation = {
+    ok: true;
+} | {
+    ok: false;
+    errors: string[];
+};
+/**
+ * Validate an accepted answer against its spec. Used by the broker before a
+ * response reaches the adapter, so malformed answers are rejected centrally.
+ */
+export declare function validateInteractionAnswer(spec: InteractionAnswerSpec, data: InteractionData | undefined): InteractionValidation;

package/dist/interaction-answer-validation.js

@@ -0,0 +1,149 @@
+import { InteractionAnswerSpecSchema, } from "./interaction-fields.js";
+import { boundedIdentifierSchema, CONTRACT_MAX_ARRAY_LENGTH, CONTRACT_MAX_MAP_ENTRIES, CONTRACT_MAX_STRING_LENGTH, } from "./contract-limits.js";
+/**
+ * Validate an accepted answer against its spec. Used by the broker before a
+ * response reaches the adapter, so malformed answers are rejected centrally.
+ */
+export function validateInteractionAnswer(spec, data) {
+    const errors = [];
+    const parsedSpec = InteractionAnswerSpecSchema.safeParse(spec);
+    if (!parsedSpec.success) {
+        return {
+            ok: false,
+            errors: parsedSpec.error.issues.map((issue) => issue.message),
+        };
+    }
+    if (data !== undefined &&
+        (!data || typeof data !== "object" || Array.isArray(data))) {
+        return { ok: false, errors: ["interaction data must be an object"] };
+    }
+    const d = data ?? Object.create(null);
+    const prototype = Object.getPrototypeOf(d);
+    if (prototype !== Object.prototype && prototype !== null) {
+        return { ok: false, errors: ["interaction data must be a plain object"] };
+    }
+    if (Object.keys(d).length > CONTRACT_MAX_MAP_ENTRIES) {
+        return { ok: false, errors: ["interaction data has too many fields"] };
+    }
+    const exactSpec = parsedSpec.data;
+    const knownFields = new Set(exactSpec.fields.map((field) => field.name));
+    for (const fieldName of Object.keys(d)) {
+        if (fieldName.length > 512) {
+            errors.push(`unknown field "${fieldName}"`);
+            continue;
+        }
+        const rawValue = d[fieldName];
+        if (typeof rawValue === "string" && rawValue.length > CONTRACT_MAX_STRING_LENGTH) {
+            errors.push(`field "${fieldName}" exceeds the contract string bound`);
+        }
+        else if (Array.isArray(rawValue)) {
+            if (rawValue.length > CONTRACT_MAX_ARRAY_LENGTH) {
+                errors.push(`field "${fieldName}" has too many values`);
+            }
+            for (const entry of rawValue) {
+                if (typeof entry !== "string" || entry.length > CONTRACT_MAX_STRING_LENGTH) {
+                    errors.push(`field "${fieldName}" contains an invalid bounded value`);
+                    break;
+                }
+            }
+        }
+        else if (rawValue && typeof rawValue === "object") {
+            const valuePrototype = Object.getPrototypeOf(rawValue);
+            if ((valuePrototype !== Object.prototype && valuePrototype !== null) ||
+                Object.keys(rawValue).length > 3) {
+                errors.push(`field "${fieldName}" contains an invalid object value`);
+            }
+        }
+        if (!knownFields.has(fieldName)) {
+            errors.push(`unknown field "${fieldName}"`);
+        }
+    }
+    for (const field of exactSpec.fields) {
+        const hasValue = Object.hasOwn(d, field.name);
+        const v = hasValue ? d[field.name] : undefined;
+        const present = hasValue && v !== undefined && v !== null && !(typeof v === "string" && v === "");
+        if (!present) {
+            if (field.required)
+                errors.push(`missing required field "${field.name}"`);
+            continue;
+        }
+        switch (field.type) {
+            case "text":
+                if (typeof v !== "string") {
+                    errors.push(`field "${field.name}" must be a string`);
+                }
+                else if (field.maxLength !== undefined && v.length > field.maxLength) {
+                    errors.push(`field "${field.name}" exceeds maxLength ${field.maxLength}`);
+                }
+                break;
+            case "secret": {
+                const isHandle = typeof v === "object" &&
+                    v !== null &&
+                    !Array.isArray(v) &&
+                    Object.keys(v).length === 3 &&
+                    (Object.getPrototypeOf(v) === Object.prototype ||
+                        Object.getPrototypeOf(v) === null) &&
+                    Object.hasOwn(v, "kind") &&
+                    Object.hasOwn(v, "handleId") &&
+                    Object.hasOwn(v, "oneUse") &&
+                    v.kind === "secret_handle" &&
+                    v.oneUse === true &&
+                    boundedIdentifierSchema.safeParse(v.handleId)
+                        .success;
+                if (typeof v !== "string" && !isHandle) {
+                    errors.push(`field "${field.name}" must be a string or one-use secret handle`);
+                }
+                else if (typeof v === "string" &&
+                    field.maxLength !== undefined &&
+                    v.length > field.maxLength) {
+                    errors.push(`field "${field.name}" exceeds maxLength ${field.maxLength}`);
+                }
+                break;
+            }
+            case "number":
+                if (typeof v !== "number" || !Number.isFinite(v)) {
+                    errors.push(`field "${field.name}" must be a finite number`);
+                }
+                else {
+                    if (field.min !== undefined && v < field.min)
+                        errors.push(`field "${field.name}" below min ${field.min}`);
+                    if (field.max !== undefined && v > field.max)
+                        errors.push(`field "${field.name}" above max ${field.max}`);
+                }
+                break;
+            case "boolean":
+                if (typeof v !== "boolean")
+                    errors.push(`field "${field.name}" must be a boolean`);
+                break;
+            case "select": {
+                if (!Array.isArray(v)) {
+                    errors.push(`field "${field.name}" must be an array of option values`);
+                    break;
+                }
+                if (v.length > CONTRACT_MAX_ARRAY_LENGTH) {
+                    errors.push(`field "${field.name}" has too many option values`);
+                    break;
+                }
+                if (!field.multi && v.length > 1)
+                    errors.push(`field "${field.name}" accepts a single value`);
+                if (field.required && v.length === 0)
+                    errors.push(`field "${field.name}" requires a selection`);
+                const allowed = new Set(field.options.map((o) => o.value));
+                for (const choice of v) {
+                    if (allowed.has(choice))
+                        continue;
+                    if (field.allowCustom === true) {
+                        // Write-ins are open but stay fail-closed on shape: string, non-blank.
+                        if (typeof choice !== "string" || choice.trim() === "") {
+                            errors.push(`field "${field.name}" has blank write-in value`);
+                        }
+                        continue;
+                    }
+                    errors.push(`field "${field.name}" has invalid option "${choice}"`);
+                }
+                break;
+            }
+        }
+    }
+    return errors.length === 0 ? { ok: true } : { ok: false, errors };
+}

package/dist/interaction-data.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export declare const InteractionSecretReferenceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"secret_handle">;
+    handleId: z.ZodString;
+    oneUse: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export type InteractionSecretReference = z.infer<typeof InteractionSecretReferenceSchema>;
+export type InteractionDataValue = string | number | boolean | string[] | InteractionSecretReference;
+/** Field values keyed by InteractionField.name. */
+export declare const InteractionDataSchema: z.ZodType<Record<string, InteractionDataValue>>;
+export type InteractionData = Record<string, InteractionDataValue>;
+export declare const InteractionResolutionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"accepted">;
+    data: z.ZodOptional<z.ZodType<Record<string, InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, InteractionDataValue>, unknown>>>;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodLiteral<"declined">;
+    data: z.ZodOptional<z.ZodType<Record<string, InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, InteractionDataValue>, unknown>>>;
+}, z.core.$strict>, z.ZodObject<{
+    outcome: z.ZodLiteral<"cancelled">;
+    data: z.ZodOptional<z.ZodType<Record<string, InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, InteractionDataValue>, unknown>>>;
+}, z.core.$strict>], "outcome">;
+export type InteractionResolution = z.infer<typeof InteractionResolutionSchema>;

package/dist/interaction-data.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { boundedIdentifierSchema, boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH, CONTRACT_MAX_MAP_ENTRIES, } from "./contract-limits.js";
+import { InteractionFieldNameSchema } from "./interaction-fields.js";
+export const InteractionSecretReferenceSchema = z.strictObject({
+    kind: z.literal("secret_handle"),
+    handleId: boundedIdentifierSchema,
+    oneUse: z.literal(true),
+});
+const InteractionDataValueSchema = z.union([
+    boundedStringSchema,
+    z.number().finite(),
+    z.boolean(),
+    z.array(boundedStringSchema).max(CONTRACT_MAX_ARRAY_LENGTH),
+    InteractionSecretReferenceSchema,
+]);
+/** Field values keyed by InteractionField.name. */
+export const InteractionDataSchema = z
+    .record(InteractionFieldNameSchema, InteractionDataValueSchema)
+    .superRefine((data, refinement) => {
+    if (Object.keys(data).length > CONTRACT_MAX_MAP_ENTRIES) {
+        refinement.addIssue({
+            code: "custom",
+            message: "interaction data has too many fields",
+        });
+    }
+})
+    .transform((data) => {
+    const safe = Object.create(null);
+    for (const key of Object.keys(data))
+        safe[key] = data[key];
+    return safe;
+});
+export const InteractionResolutionSchema = z.discriminatedUnion("outcome", [
+    z.strictObject({
+        outcome: z.literal("accepted"),
+        data: InteractionDataSchema.optional(),
+    }),
+    z.strictObject({
+        outcome: z.literal("declined"),
+        data: InteractionDataSchema.optional(),
+    }),
+    z.strictObject({
+        outcome: z.literal("cancelled"),
+        data: InteractionDataSchema.optional(),
+    }),
+]);

package/dist/interaction-envelope.d.ts

@@ -0,0 +1,267 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import { type InteractionResolution } from "./interaction-data.js";
+import { InteractionAnswerSpecSchema, InteractionResponseScopeSchema } from "./interaction-fields.js";
+export { InteractionDataSchema, InteractionResolutionSchema, InteractionSecretReferenceSchema, } from "./interaction-data.js";
+export type { InteractionData, InteractionDataValue, InteractionResolution, InteractionSecretReference, } from "./interaction-data.js";
+export declare const InteractionSubjectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"tool">;
+    toolName: z.ZodString;
+    input: z.ZodOptional<z.ZodCustom<unknown, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"command">;
+    command: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    path: z.ZodString;
+    preview: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"resource">;
+    uri: z.ZodString;
+}, z.core.$strict>], "type">;
+export type InteractionSubject = z.infer<typeof InteractionSubjectSchema>;
+export declare const InteractionOutcomeSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    accepted: "accepted";
+    declined: "declined";
+}>;
+export type InteractionOutcome = z.infer<typeof InteractionOutcomeSchema>;
+export declare const InteractionRequestBindingSchema: z.ZodObject<{
+    runId: z.ZodString;
+    provider: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    executionId: z.ZodString;
+    interactionId: z.ZodString;
+}, z.core.$strict>;
+export type InteractionRequestBinding = z.infer<typeof InteractionRequestBindingSchema>;
+/** Exact execution coordinates shared by every interaction from one provider turn. */
+export declare const InteractionExecutionBindingSchema: z.ZodObject<{
+    provider: z.ZodString;
+    executionId: z.ZodString;
+    runId: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export type InteractionExecutionBinding = z.infer<typeof InteractionExecutionBindingSchema>;
+/** Binding carried by a response command and acknowledgement. */
+export declare const InteractionBindingSchema: z.ZodObject<{
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    runId: z.ZodString;
+    provider: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    executionId: z.ZodString;
+    interactionId: z.ZodString;
+}, z.core.$strict>;
+export type InteractionBinding = z.infer<typeof InteractionBindingSchema>;
+export interface InteractionRequestMaterial {
+    id: string;
+    kind: string;
+    title: string;
+    body?: string;
+    subject?: InteractionSubject;
+    answerSpec: z.infer<typeof InteractionAnswerSpecSchema>;
+    responseScopes?: z.infer<typeof InteractionResponseScopeSchema>[];
+    allowedOutcomes?: InteractionOutcome[];
+    default?: InteractionResolution;
+    timeoutMs?: number;
+    onTimeout?: "default" | "fail" | "wait";
+    binding: InteractionRequestBinding;
+}
+export interface InteractionRequest extends InteractionRequestMaterial {
+    requestDigest: Sha256Digest;
+}
+export declare function interactionRequestDigest(request: InteractionRequestMaterial): Sha256Digest;
+export declare const InteractionRequestSchema: z.ZodObject<{
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    id: z.ZodString;
+    kind: z.ZodString;
+    title: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"tool">;
+        toolName: z.ZodString;
+        input: z.ZodOptional<z.ZodCustom<unknown, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"command">;
+        command: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        path: z.ZodString;
+        preview: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"resource">;
+        uri: z.ZodString;
+    }, z.core.$strict>], "type">>;
+    answerSpec: z.ZodObject<{
+        fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            multiline: z.ZodOptional<z.ZodBoolean>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            default: z.ZodOptional<z.ZodString>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"number">;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            default: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"boolean">;
+            default: z.ZodOptional<z.ZodBoolean>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"select">;
+            options: z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            multi: z.ZodOptional<z.ZodBoolean>;
+            allowCustom: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"secret">;
+            placeholder: z.ZodOptional<z.ZodString>;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>], "type">>;
+    }, z.core.$strict>;
+    responseScopes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        interaction: "interaction";
+        session: "session";
+        persistent: "persistent";
+    }>>>;
+    allowedOutcomes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        cancelled: "cancelled";
+        accepted: "accepted";
+        declined: "declined";
+    }>>>;
+    default: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        outcome: z.ZodLiteral<"accepted">;
+        data: z.ZodOptional<z.ZodType<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"declined">;
+        data: z.ZodOptional<z.ZodType<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        outcome: z.ZodLiteral<"cancelled">;
+        data: z.ZodOptional<z.ZodType<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown>>>;
+    }, z.core.$strict>], "outcome">>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    onTimeout: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        fail: "fail";
+        wait: "wait";
+    }>>;
+    binding: z.ZodObject<{
+        runId: z.ZodString;
+        provider: z.ZodString;
+        environmentId: z.ZodString;
+        sessionId: z.ZodString;
+        executionId: z.ZodString;
+        interactionId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const InteractionResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    outcome: z.ZodLiteral<"accepted">;
+    data: z.ZodOptional<z.ZodType<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    outcome: z.ZodLiteral<"declined">;
+    data: z.ZodOptional<z.ZodType<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown>>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    outcome: z.ZodLiteral<"cancelled">;
+    data: z.ZodOptional<z.ZodType<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown>>>;
+}, z.core.$strict>], "outcome">;
+export type InteractionResponse = z.infer<typeof InteractionResponseSchema>;
+export interface InteractionResponseCommandMaterial {
+    binding: InteractionBinding;
+    response: InteractionResponse;
+}
+/** Digest the exact binding and response carried by a retryable command. */
+export declare function interactionResponseCommandDigest(material: InteractionResponseCommandMaterial): Sha256Digest;
+/** Retryable command sent to an environment or retained session. */
+export declare const InteractionResponseCommandSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    binding: z.ZodObject<{
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        runId: z.ZodString;
+        provider: z.ZodString;
+        environmentId: z.ZodString;
+        sessionId: z.ZodString;
+        executionId: z.ZodString;
+        interactionId: z.ZodString;
+    }, z.core.$strict>;
+    commandDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        outcome: z.ZodLiteral<"accepted">;
+        data: z.ZodOptional<z.ZodType<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        outcome: z.ZodLiteral<"declined">;
+        data: z.ZodOptional<z.ZodType<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        outcome: z.ZodLiteral<"cancelled">;
+        data: z.ZodOptional<z.ZodType<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown, z.core.$ZodTypeInternals<Record<string, import("./interaction-data.js").InteractionDataValue>, unknown>>>;
+    }, z.core.$strict>], "outcome">;
+}, z.core.$strict>;
+export type InteractionResponseCommand = z.infer<typeof InteractionResponseCommandSchema>;
+export declare const InteractionAcknowledgementStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    expired: "expired";
+    accepted: "accepted";
+    already_resolved_same: "already_resolved_same";
+    already_resolved_different: "already_resolved_different";
+    unknown_interaction: "unknown_interaction";
+    unknown_run: "unknown_run";
+    binding_mismatch: "binding_mismatch";
+    invalid_response: "invalid_response";
+    transport_failure: "transport_failure";
+}>;
+export type InteractionAcknowledgementStatus = z.infer<typeof InteractionAcknowledgementStatusSchema>;
+/** Durable result of one interaction response operation. */
+export declare const InteractionAcknowledgementSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    binding: z.ZodObject<{
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        runId: z.ZodString;
+        provider: z.ZodString;
+        environmentId: z.ZodString;
+        sessionId: z.ZodString;
+        executionId: z.ZodString;
+        interactionId: z.ZodString;
+    }, z.core.$strict>;
+    commandDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        expired: "expired";
+        accepted: "accepted";
+        already_resolved_same: "already_resolved_same";
+        already_resolved_different: "already_resolved_different";
+        unknown_interaction: "unknown_interaction";
+        unknown_run: "unknown_run";
+        binding_mismatch: "binding_mismatch";
+        invalid_response: "invalid_response";
+        transport_failure: "transport_failure";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type InteractionAcknowledgement = z.infer<typeof InteractionAcknowledgementSchema>;