@tangle-network/agent-interface 0.55.0 → 0.56.0

package/dist/environment-interactive.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
 import { canonicalCandidateDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
-import { canonicalAgentProfileDigest } from "./agent-execution-preparation.js";
+import { agentExecutionPreparationReceiptSchema, canonicalAgentProfileDigest, } from "./agent-execution-preparation.js";
 import { boundedIdentifierSchema, boundedStringSchema, } from "./contract-limits.js";
-import { harnessTypeSchema } from "./harness.js";
 import { agentProfileSchema } from "./profile-schema.js";
 import { AgentExactRunControlRefSchema, } from "./runtime-control.js";
 const INTERACTIVE_MAX_DIMENSION = 10_000;
@@ -20,21 +19,210 @@ const AgentInteractiveSessionRunCoordinatesSchema = z.strictObject({
 /**
  * Durable identity of one coding-agent TUI.
  *
- * This reference identifies the exact admitted run and effective profile.
+ * This reference identifies the exact admitted run and preparation receipt.
  * It is not a generic shell id and cannot be used to create another process.
  */
 export const AgentInteractiveSessionRefSchema = z.strictObject({
     run: AgentExactRunControlRefSchema,
-    /** Canonical digest of the AgentProfile submitted by the caller. */
-    requestedProfileDigest: sha256DigestSchema,
-    /** Canonical digest of the effective profile the provider admitted. */
-    admittedProfileDigest: sha256DigestSchema,
+    /** Canonical executor receipt containing the effective route and its proof. */
+    preparationReceipt: agentExecutionPreparationReceiptSchema,
     /** Provider-issued identity of this exact process incarnation. */
     incarnationId: boundedIdentifierSchema,
-    harness: harnessTypeSchema,
     startedAt: z.iso.datetime().max(64),
 });
-/** Start one native coding-agent TUI for an already admitted run. */
+/**
+ * Provider-issued write authority for one exact interactive process.
+ *
+ * Expiry blocks mutations but does not kill the coding process. A coordinator
+ * can issue a new compare-and-swap claim after expiry. The provider's PTY owner
+ * lease remains the separate process-cleanup authority.
+ */
+export const AgentInteractiveSessionControlClaimSchema = z.strictObject({
+    /** Canonical identity of the process ref this authority can mutate. */
+    refDigest: sha256DigestSchema,
+    /** Provider generation. A recovered coordinator must obtain a greater value. */
+    generation: z.number().int().positive().safe(),
+    /** Provider lease identity for this generation. */
+    leaseId: boundedIdentifierSchema,
+    /** Stable identity of the coordinator holding this lease. */
+    holderId: boundedIdentifierSchema,
+    expiresAt: z.iso.datetime().max(64),
+});
+const AgentInteractiveSessionControlClaimRequestMaterialSchema = z.strictObject({
+    operationId: boundedIdentifierSchema,
+    ref: AgentInteractiveSessionRefSchema,
+    holderId: boundedIdentifierSchema,
+    expectedGeneration: z.number().int().nonnegative().safe(),
+});
+export function agentInteractiveSessionControlClaimRequestDigest(value) {
+    const parsed = AgentInteractiveSessionControlClaimRequestMaterialSchema.parse(value);
+    return canonicalCandidateDigest({
+        kind: "agent-interactive-session-control-claim.v1",
+        operationId: parsed.operationId,
+        ref: parsed.ref,
+        holderId: parsed.holderId,
+        expectedGeneration: parsed.expectedGeneration,
+    });
+}
+export const AgentInteractiveSessionControlClaimRequestSchema = z
+    .strictObject({
+    ...AgentInteractiveSessionControlClaimRequestMaterialSchema.shape,
+    requestDigest: sha256DigestSchema,
+})
+    .superRefine((request, refinement) => {
+    const { requestDigest: _requestDigest, ...material } = request;
+    if (request.requestDigest !==
+        agentInteractiveSessionControlClaimRequestDigest(material)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "interactive session control claim request digest does not match its content",
+        });
+    }
+});
+export const AgentInteractiveSessionControlClaimAcknowledgementSchema = z
+    .strictObject({
+    operationId: boundedIdentifierSchema,
+    requestDigest: sha256DigestSchema,
+    ref: AgentInteractiveSessionRefSchema,
+    status: z.enum(["accepted", "replayed", "conflict", "unknown"]),
+    control: AgentInteractiveSessionControlClaimSchema.optional(),
+    conflictReason: z
+        .enum(["generation_mismatch", "operation_reuse"])
+        .optional(),
+    currentGeneration: z.number().int().nonnegative().safe().optional(),
+    existingRequestDigest: sha256DigestSchema.optional(),
+    message: boundedStringSchema.min(1).optional(),
+    retryable: z.boolean().optional(),
+})
+    .superRefine((acknowledgement, refinement) => {
+    const hasControl = acknowledgement.control !== undefined;
+    if ((acknowledgement.status === "accepted" ||
+        acknowledgement.status === "replayed") &&
+        !hasControl) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["control"],
+            message: "an accepted control claim must return its provider claim",
+        });
+    }
+    if (acknowledgement.status !== "accepted" &&
+        acknowledgement.status !== "replayed" &&
+        hasControl) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["control"],
+            message: "only an accepted or replayed claim may return control",
+        });
+    }
+    if (acknowledgement.status === "conflict" &&
+        acknowledgement.conflictReason === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["conflictReason"],
+            message: "a control claim conflict must distinguish generation mismatch from operation reuse",
+        });
+    }
+    if (acknowledgement.status !== "conflict" &&
+        acknowledgement.conflictReason !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["conflictReason"],
+            message: "only a control claim conflict may report a conflict reason",
+        });
+    }
+    if (hasControl &&
+        !agentInteractiveSessionControlClaimMatchesRef(acknowledgement.ref, acknowledgement.control)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["control", "refDigest"],
+            message: "interactive control claim acknowledgement does not match its process ref",
+        });
+    }
+    if (acknowledgement.status === "conflict" &&
+        acknowledgement.currentGeneration === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["currentGeneration"],
+            message: "a control claim conflict must report the current generation",
+        });
+    }
+    if (acknowledgement.conflictReason === "generation_mismatch" &&
+        acknowledgement.existingRequestDigest !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a generation mismatch must not be reported as operation reuse",
+        });
+    }
+    if (acknowledgement.conflictReason === "operation_reuse" &&
+        acknowledgement.existingRequestDigest === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "operation reuse must report the digest already stored for this operation",
+        });
+    }
+    if (acknowledgement.status === "conflict" &&
+        acknowledgement.existingRequestDigest === acknowledgement.requestDigest) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a control claim conflict must identify different request material",
+        });
+    }
+    if (acknowledgement.status !== "conflict" &&
+        (acknowledgement.currentGeneration !== undefined ||
+            acknowledgement.existingRequestDigest !== undefined)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["currentGeneration"],
+            message: "only a control claim conflict may report existing generation state",
+        });
+    }
+    if (acknowledgement.status === "unknown" &&
+        (acknowledgement.message === undefined || acknowledgement.retryable !== true)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["retryable"],
+            message: "an unknown control claim outcome must explicitly permit safe same-operation retry",
+        });
+    }
+});
+export function agentInteractiveSessionControlClaimAcknowledgementMatchesRequest(request, acknowledgement) {
+    const exactRequest = AgentInteractiveSessionControlClaimRequestSchema.safeParse(request);
+    const exactAcknowledgement = AgentInteractiveSessionControlClaimAcknowledgementSchema.safeParse(acknowledgement);
+    if (!exactRequest.success || !exactAcknowledgement.success)
+        return false;
+    return (exactAcknowledgement.data.operationId === exactRequest.data.operationId &&
+        exactAcknowledgement.data.requestDigest === exactRequest.data.requestDigest &&
+        canonicalCandidateDigest(exactAcknowledgement.data.ref) ===
+            canonicalCandidateDigest(exactRequest.data.ref));
+}
+/** Bind a provider-issued control claim to the exact process it can mutate. */
+export function agentInteractiveSessionControlClaimMatchesRef(ref, claim) {
+    const parsedRef = AgentInteractiveSessionRefSchema.safeParse(ref);
+    const parsedClaim = AgentInteractiveSessionControlClaimSchema.safeParse(claim);
+    return (parsedRef.success &&
+        parsedClaim.success &&
+        parsedClaim.data.refDigest === canonicalCandidateDigest(parsedRef.data));
+}
+/** Compare two claims for one process without making a provider state claim. */
+export function agentInteractiveSessionControlClaimIsNewer(candidate, current) {
+    const parsedCandidate = AgentInteractiveSessionControlClaimSchema.safeParse(candidate);
+    const parsedCurrent = AgentInteractiveSessionControlClaimSchema.safeParse(current);
+    return (parsedCandidate.success &&
+        parsedCurrent.success &&
+        parsedCandidate.data.refDigest === parsedCurrent.data.refDigest &&
+        parsedCandidate.data.generation > parsedCurrent.data.generation);
+}
+/**
+ * Start one native coding-agent TUI from caller-owned request material.
+ *
+ * The provider owns profile materialization and returns its preparation receipt
+ * in the resulting reference. Replaying the same exact request/run returns the
+ * same reference, even after the process exits; changed material cannot reuse it.
+ */
 export const AgentInteractiveSessionStartSchema = z.strictObject({
     run: AgentExactRunControlRefSchema,
     profile: agentProfileSchema,
@@ -72,6 +260,8 @@ export function agentInteractiveSessionRunRef(coordinates, input) {
 }
 /** Geometry for one attachment to the existing coding-agent TUI. */
 export const AgentInteractiveSessionAttachSchema = z.strictObject({
+    /** Required because the returned terminal permits input and resize. */
+    control: AgentInteractiveSessionControlClaimSchema,
     cols: interactiveDimensionSchema.optional(),
     rows: interactiveDimensionSchema.optional(),
 });
@@ -96,6 +286,215 @@ export const AgentInteractiveSessionStatusSchema = z.discriminatedUnion("state",
         retryable: z.boolean(),
     }),
 ]);
+const AgentInteractiveSessionStopCommandMaterialSchema = z
+    .strictObject({
+    operationId: boundedIdentifierSchema,
+    ref: AgentInteractiveSessionRefSchema,
+    control: AgentInteractiveSessionControlClaimSchema,
+})
+    .superRefine((command, refinement) => {
+    if (!agentInteractiveSessionControlClaimMatchesRef(command.ref, command.control)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["control", "refDigest"],
+            message: "interactive stop control claim does not match its process ref",
+        });
+    }
+});
+export function agentInteractiveSessionStopRequestDigest(value) {
+    const parsed = AgentInteractiveSessionStopCommandMaterialSchema.parse(value);
+    return canonicalCandidateDigest({
+        kind: "agent-interactive-session-stop.v1",
+        operationId: parsed.operationId,
+        ref: parsed.ref,
+        control: parsed.control,
+    });
+}
+export const AgentInteractiveSessionStopCommandSchema = z
+    .strictObject({
+    ...AgentInteractiveSessionStopCommandMaterialSchema.shape,
+    requestDigest: sha256DigestSchema,
+})
+    .superRefine((command, refinement) => {
+    const { requestDigest: _requestDigest, ...material } = command;
+    if (command.requestDigest !==
+        agentInteractiveSessionStopRequestDigest(material)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "interactive stop request digest does not match its content",
+        });
+    }
+});
+export const AgentInteractiveSessionStopAcknowledgementSchema = z
+    .strictObject({
+    operationId: boundedIdentifierSchema,
+    requestDigest: sha256DigestSchema,
+    ref: AgentInteractiveSessionRefSchema,
+    control: AgentInteractiveSessionControlClaimSchema,
+    status: z.enum(["accepted", "replayed", "conflict", "unknown"]),
+    effect: z.enum(["stop_requested", "stopped", "not_live", "unknown"]),
+    message: boundedStringSchema.min(1).optional(),
+    retryable: z.boolean().optional(),
+    existingRequestDigest: sha256DigestSchema.optional(),
+})
+    .superRefine((acknowledgement, refinement) => {
+    if (!agentInteractiveSessionControlClaimMatchesRef(acknowledgement.ref, acknowledgement.control)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["control", "refDigest"],
+            message: "interactive stop acknowledgement control does not match its process ref",
+        });
+    }
+    const known = acknowledgement.effect !== "unknown";
+    if (((acknowledgement.status === "accepted" ||
+        acknowledgement.status === "replayed") &&
+        !known) ||
+        ((acknowledgement.status === "conflict" ||
+            acknowledgement.status === "unknown") &&
+            known)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["effect"],
+            message: "interactive stop status and effect certainty do not agree",
+        });
+    }
+    if (acknowledgement.status === "conflict" &&
+        (acknowledgement.existingRequestDigest === undefined ||
+            acknowledgement.existingRequestDigest === acknowledgement.requestDigest)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "an interactive stop conflict must identify a different existing request",
+        });
+    }
+    if (acknowledgement.status !== "conflict" &&
+        acknowledgement.existingRequestDigest !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "only an interactive stop conflict may include an existing digest",
+        });
+    }
+    if (acknowledgement.status === "unknown" &&
+        (acknowledgement.message === undefined || acknowledgement.retryable !== true)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["retryable"],
+            message: "an unknown interactive stop outcome must explicitly permit safe same-operation retry",
+        });
+    }
+});
+export function agentInteractiveSessionStopAcknowledgementMatchesCommand(command, acknowledgement) {
+    const exactCommand = AgentInteractiveSessionStopCommandSchema.safeParse(command);
+    const exactAcknowledgement = AgentInteractiveSessionStopAcknowledgementSchema.safeParse(acknowledgement);
+    if (!exactCommand.success || !exactAcknowledgement.success)
+        return false;
+    return (exactAcknowledgement.data.operationId === exactCommand.data.operationId &&
+        exactAcknowledgement.data.requestDigest === exactCommand.data.requestDigest &&
+        canonicalCandidateDigest(exactAcknowledgement.data.ref) ===
+            canonicalCandidateDigest(exactCommand.data.ref) &&
+        canonicalCandidateDigest(exactAcknowledgement.data.control) ===
+            canonicalCandidateDigest(exactCommand.data.control));
+}
+const AgentInteractiveSessionPromptCommandMaterialSchema = z
+    .strictObject({
+    operationId: boundedIdentifierSchema,
+    ref: AgentInteractiveSessionRefSchema,
+    control: AgentInteractiveSessionControlClaimSchema,
+    prompt: boundedStringSchema.min(1),
+})
+    .superRefine((command, refinement) => {
+    if (!agentInteractiveSessionControlClaimMatchesRef(command.ref, command.control)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["control", "refDigest"],
+            message: "interactive prompt control claim does not match its process ref",
+        });
+    }
+});
+export function agentInteractiveSessionPromptRequestDigest(value) {
+    const parsed = AgentInteractiveSessionPromptCommandMaterialSchema.parse(value);
+    return canonicalCandidateDigest({
+        kind: "agent-interactive-session-prompt.v1",
+        operationId: parsed.operationId,
+        ref: parsed.ref,
+        control: parsed.control,
+        prompt: parsed.prompt,
+    });
+}
+export const AgentInteractiveSessionPromptCommandSchema = z
+    .strictObject({
+    ...AgentInteractiveSessionPromptCommandMaterialSchema.shape,
+    requestDigest: sha256DigestSchema,
+})
+    .superRefine((command, refinement) => {
+    const { requestDigest: _requestDigest, ...material } = command;
+    if (command.requestDigest !== agentInteractiveSessionPromptRequestDigest(material)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "interactive session prompt request digest does not match its content",
+        });
+    }
+});
+export const AgentInteractiveSessionPromptAcknowledgementSchema = z
+    .strictObject({
+    operationId: boundedIdentifierSchema,
+    requestDigest: sha256DigestSchema,
+    ref: AgentInteractiveSessionRefSchema,
+    control: AgentInteractiveSessionControlClaimSchema,
+    status: z.enum(["accepted", "replayed", "conflict", "unknown"]),
+    message: boundedStringSchema.min(1).optional(),
+    retryable: z.boolean().optional(),
+    existingRequestDigest: sha256DigestSchema.optional(),
+})
+    .superRefine((acknowledgement, refinement) => {
+    if (!agentInteractiveSessionControlClaimMatchesRef(acknowledgement.ref, acknowledgement.control)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["control", "refDigest"],
+            message: "interactive prompt acknowledgement control claim does not match its process ref",
+        });
+    }
+    if (acknowledgement.status === "conflict" &&
+        (acknowledgement.existingRequestDigest === undefined ||
+            acknowledgement.existingRequestDigest === acknowledgement.requestDigest)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "an interactive prompt conflict must identify a different existing request",
+        });
+    }
+    if (acknowledgement.status !== "conflict" &&
+        acknowledgement.existingRequestDigest !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "only an interactive prompt conflict may include an existing digest",
+        });
+    }
+    if (acknowledgement.status === "unknown" &&
+        (acknowledgement.message === undefined || acknowledgement.retryable !== true)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["retryable"],
+            message: "an unknown interactive prompt outcome must explicitly permit safe same-operation retry",
+        });
+    }
+});
+export function agentInteractiveSessionPromptAcknowledgementMatchesCommand(command, acknowledgement) {
+    const exactCommand = AgentInteractiveSessionPromptCommandSchema.safeParse(command);
+    const exactAcknowledgement = AgentInteractiveSessionPromptAcknowledgementSchema.safeParse(acknowledgement);
+    if (!exactCommand.success || !exactAcknowledgement.success)
+        return false;
+    return (exactAcknowledgement.data.operationId === exactCommand.data.operationId &&
+        exactAcknowledgement.data.requestDigest === exactCommand.data.requestDigest &&
+        canonicalCandidateDigest(exactAcknowledgement.data.ref) ===
+            canonicalCandidateDigest(exactCommand.data.ref) &&
+        canonicalCandidateDigest(exactAcknowledgement.data.control) ===
+            canonicalCandidateDigest(exactCommand.data.control));
+}
 /** Parse a start request and prove its profile identity before provider work. */
 export function exactAgentInteractiveSessionStart(value) {
     const parsed = AgentInteractiveSessionStartSchema.parse(value);
@@ -113,18 +512,18 @@ export function exactAgentInteractiveSessionStart(value) {
     }
     return parsed;
 }
-/** Prove that a provider returned the exact run, profile, and runner requested. */
+/** Prove that a provider returned the exact run and preparation receipt requested. */
 export function agentInteractiveSessionRefMatchesStart(request, ref) {
     const parsedRequest = AgentInteractiveSessionStartSchema.safeParse(request);
     const parsedRef = AgentInteractiveSessionRefSchema.safeParse(ref);
     if (!parsedRequest.success || !parsedRef.success)
         return false;
-    const harness = parsedRequest.data.profile.harness;
-    if (harness === undefined)
+    const requestedHarness = parsedRequest.data.profile.harness;
+    if (requestedHarness === undefined)
         return false;
-    return (parsedRef.data.requestedProfileDigest ===
+    return (parsedRef.data.preparationReceipt.authoredProfileDigest ===
         parsedRequest.data.requestedProfileDigest &&
-        parsedRef.data.harness === harness &&
+        parsedRef.data.preparationReceipt.harness === requestedHarness &&
         sameExactRun(parsedRef.data.run, parsedRequest.data.run));
 }
 /** Prove that a status belongs to the handle that requested it. */
@@ -134,10 +533,9 @@ export function agentInteractiveSessionStatusMatchesRef(ref, status) {
     if (!parsedRef.success || !parsedStatus.success)
         return false;
     const observed = parsedStatus.data.ref;
-    return (observed.requestedProfileDigest === parsedRef.data.requestedProfileDigest &&
-        observed.admittedProfileDigest === parsedRef.data.admittedProfileDigest &&
+    return (observed.preparationReceipt.digest ===
+        parsedRef.data.preparationReceipt.digest &&
         observed.incarnationId === parsedRef.data.incarnationId &&
-        observed.harness === parsedRef.data.harness &&
         observed.startedAt === parsedRef.data.startedAt &&
         sameExactRun(observed.run, parsedRef.data.run));
 }

package/dist/environment-runtime.d.ts

@@ -776,6 +776,8 @@ export interface AgentEnvironmentCapabilities {
     /** Present only when the provider can start and rediscover exact agent TUIs. */
     interactiveAgent?: {
         start: boolean;
+        /** Provider-issued generation claims fence recovered coordinators. */
+        control: boolean;
         status: boolean;
         attach: boolean;
         reattach: boolean;
@@ -895,6 +897,7 @@ export declare const AgentEnvironmentCapabilitiesSchema: z.ZodObject<{
     }, z.core.$strict>>;
     interactiveAgent: z.ZodOptional<z.ZodObject<{
         start: z.ZodBoolean;
+        control: z.ZodBoolean;
         status: z.ZodBoolean;
         attach: z.ZodBoolean;
         reattach: z.ZodBoolean;

package/dist/environment-runtime.js

@@ -192,6 +192,7 @@ export const AgentEnvironmentCapabilitiesSchema = z
     interactiveAgent: z
         .strictObject({
         start: z.boolean(),
+        control: z.boolean(),
         status: z.boolean(),
         attach: z.boolean(),
         reattach: z.boolean(),
@@ -277,6 +278,19 @@ export const AgentEnvironmentCapabilitiesSchema = z
             message: "interactive agent status, attach, reattach, sendPrompt, input, resize, and stop each require start",
         });
     }
+    if (interactiveAgent !== undefined &&
+        (interactiveAgent.attach ||
+            interactiveAgent.sendPrompt ||
+            interactiveAgent.input ||
+            interactiveAgent.resize ||
+            interactiveAgent.stop) &&
+        !interactiveAgent.control) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["interactiveAgent", "control"],
+            message: "interactive agent mutation requires provider-issued control claims",
+        });
+    }
     if (interactiveAgent !== undefined &&
         (interactiveAgent.reattach || interactiveAgent.input || interactiveAgent.resize) &&
         !interactiveAgent.attach) {

package/dist/index.d.ts

@@ -8,7 +8,7 @@ export * from "./host-services.js";
 export * from "./mcp.js";
 export * from "./provider-adapter.js";
 export type * from "./environment-provider.js";
-export { AgentEnvironmentCapabilitiesSchema, AgentNativeContextContinuationResultSchema, AgentTurnInputSchema, AgentTurnResultSchema, agentNativeContextContinuationResultMatchesRequest, AccountUsageSchema, AgentEnvironmentObservationSchema, AgentEnvironmentStatusSchema, ComputeBillingSchema, EnvironmentLifecycleSchema, ModelUsageSchema, ObservationProvenanceSchema, ObservationStateSchema, PlacementDescriptorSchema, ProviderIdentitySchema, ResourceProfileSchema, ResourceUseSampleSchema, SafeEndpointSchema, agentEnvironmentObservationIdentityMatches, assertObservationCredentialFree, observationContainsCredential, observationOf, AgentInteractiveSessionAttachSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStartSchema, AgentInteractiveSessionStatusSchema, agentInteractiveSessionRequestDigest, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, exactAgentInteractiveSessionStart, TerminalAttachRequestSchema, TerminalAttachResultSchema, TerminalDetachAckSchema, TerminalInputSchema, TerminalOutputEventSchema, TerminalReplayWindowSchema, TerminalResizeSchema, TerminalSessionRefSchema, terminalAttachResultMatchesRequest, terminalSessionUsable, } from "./environment-provider.js";
+export { AgentEnvironmentCapabilitiesSchema, AgentNativeContextContinuationResultSchema, AgentTurnInputSchema, AgentTurnResultSchema, agentNativeContextContinuationResultMatchesRequest, AccountUsageSchema, AgentEnvironmentObservationSchema, AgentEnvironmentStatusSchema, ComputeBillingSchema, EnvironmentLifecycleSchema, ModelUsageSchema, ObservationProvenanceSchema, ObservationStateSchema, PlacementDescriptorSchema, ProviderIdentitySchema, ResourceProfileSchema, ResourceUseSampleSchema, SafeEndpointSchema, agentEnvironmentObservationIdentityMatches, assertObservationCredentialFree, observationContainsCredential, observationOf, AgentInteractiveSessionAttachSchema, AgentInteractiveSessionControlClaimAcknowledgementSchema, AgentInteractiveSessionControlClaimRequestSchema, AgentInteractiveSessionControlClaimSchema, AgentInteractiveSessionPromptAcknowledgementSchema, AgentInteractiveSessionPromptCommandSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStartSchema, AgentInteractiveSessionStopAcknowledgementSchema, AgentInteractiveSessionStopCommandSchema, AgentInteractiveSessionStatusSchema, agentInteractiveSessionControlClaimAcknowledgementMatchesRequest, agentInteractiveSessionControlClaimRequestDigest, agentInteractiveSessionControlClaimMatchesRef, agentInteractiveSessionControlClaimIsNewer, agentInteractiveSessionPromptAcknowledgementMatchesCommand, agentInteractiveSessionPromptRequestDigest, agentInteractiveSessionStopAcknowledgementMatchesCommand, agentInteractiveSessionStopRequestDigest, agentInteractiveSessionRequestDigest, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, exactAgentInteractiveSessionStart, TerminalAttachRequestSchema, TerminalAttachResultSchema, TerminalDetachAckSchema, TerminalInputSchema, TerminalOutputEventSchema, TerminalReplayWindowSchema, TerminalResizeSchema, TerminalSessionRefSchema, terminalAttachResultMatchesRequest, terminalSessionUsable, } from "./environment-provider.js";
 export * from "./plan.js";
 export * from "./runtime-control.js";
 export * from "./portable-context.js";

package/dist/index.js

@@ -7,7 +7,7 @@ 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, AccountUsageSchema, AgentEnvironmentObservationSchema, AgentEnvironmentStatusSchema, ComputeBillingSchema, EnvironmentLifecycleSchema, ModelUsageSchema, ObservationProvenanceSchema, ObservationStateSchema, PlacementDescriptorSchema, ProviderIdentitySchema, ResourceProfileSchema, ResourceUseSampleSchema, SafeEndpointSchema, agentEnvironmentObservationIdentityMatches, assertObservationCredentialFree, observationContainsCredential, observationOf, AgentInteractiveSessionAttachSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStartSchema, AgentInteractiveSessionStatusSchema, agentInteractiveSessionRequestDigest, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, exactAgentInteractiveSessionStart, TerminalAttachRequestSchema, TerminalAttachResultSchema, TerminalDetachAckSchema, TerminalInputSchema, TerminalOutputEventSchema, TerminalReplayWindowSchema, TerminalResizeSchema, TerminalSessionRefSchema, terminalAttachResultMatchesRequest, terminalSessionUsable, } from "./environment-provider.js";
+export { AgentEnvironmentCapabilitiesSchema, AgentNativeContextContinuationResultSchema, AgentTurnInputSchema, AgentTurnResultSchema, agentNativeContextContinuationResultMatchesRequest, AccountUsageSchema, AgentEnvironmentObservationSchema, AgentEnvironmentStatusSchema, ComputeBillingSchema, EnvironmentLifecycleSchema, ModelUsageSchema, ObservationProvenanceSchema, ObservationStateSchema, PlacementDescriptorSchema, ProviderIdentitySchema, ResourceProfileSchema, ResourceUseSampleSchema, SafeEndpointSchema, agentEnvironmentObservationIdentityMatches, assertObservationCredentialFree, observationContainsCredential, observationOf, AgentInteractiveSessionAttachSchema, AgentInteractiveSessionControlClaimAcknowledgementSchema, AgentInteractiveSessionControlClaimRequestSchema, AgentInteractiveSessionControlClaimSchema, AgentInteractiveSessionPromptAcknowledgementSchema, AgentInteractiveSessionPromptCommandSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStartSchema, AgentInteractiveSessionStopAcknowledgementSchema, AgentInteractiveSessionStopCommandSchema, AgentInteractiveSessionStatusSchema, agentInteractiveSessionControlClaimAcknowledgementMatchesRequest, agentInteractiveSessionControlClaimRequestDigest, agentInteractiveSessionControlClaimMatchesRef, agentInteractiveSessionControlClaimIsNewer, agentInteractiveSessionPromptAcknowledgementMatchesCommand, agentInteractiveSessionPromptRequestDigest, agentInteractiveSessionStopAcknowledgementMatchesCommand, agentInteractiveSessionStopRequestDigest, agentInteractiveSessionRequestDigest, agentInteractiveSessionRefMatchesStart, agentInteractiveSessionRunRef, agentInteractiveSessionStatusMatchesRef, exactAgentInteractiveSessionStart, TerminalAttachRequestSchema, TerminalAttachResultSchema, TerminalDetachAckSchema, TerminalInputSchema, TerminalOutputEventSchema, TerminalReplayWindowSchema, TerminalResizeSchema, TerminalSessionRefSchema, terminalAttachResultMatchesRequest, terminalSessionUsable, } from "./environment-provider.js";
 export * from "./plan.js";
 export * from "./runtime-control.js";
 export * from "./portable-context.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-interface",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",