@tangle-network/agent-interface 0.48.0 → 0.49.0

package/dist/environment-observation.js

@@ -0,0 +1,306 @@
+import { z } from "zod";
+import { boundedIdentifierSchema, boundedStringSchema, } from "./contract-limits.js";
+export const ObservationStateSchema = z.enum([
+    "known",
+    "stale",
+    "unavailable",
+    "redacted",
+    "unknown",
+]);
+export const ObservationProvenanceSchema = z.strictObject({
+    origin: z.enum(["measured", "reported", "estimated"]),
+    observedAt: z.iso.datetime().max(64),
+    source: boundedIdentifierSchema.optional(),
+});
+/** Build a freshness-tagged observation schema around one value schema. */
+export function observationOf(value) {
+    return z.discriminatedUnion("state", [
+        z.strictObject({
+            state: z.literal("known"),
+            value,
+            provenance: ObservationProvenanceSchema,
+        }),
+        z.strictObject({
+            state: z.literal("stale"),
+            value,
+            provenance: ObservationProvenanceSchema,
+            reason: boundedStringSchema.min(1),
+        }),
+        z.strictObject({
+            state: z.literal("unavailable"),
+            reason: boundedStringSchema.min(1),
+        }),
+        z.strictObject({
+            state: z.literal("redacted"),
+            reason: boundedStringSchema.min(1),
+        }),
+        z.strictObject({ state: z.literal("unknown") }),
+    ]);
+}
+const nonNegativeNumberSchema = z.number().finite().nonnegative();
+export const ProviderIdentitySchema = z.strictObject({
+    provider: boundedIdentifierSchema,
+    environmentId: boundedIdentifierSchema,
+    sessionId: boundedIdentifierSchema.optional(),
+    backend: boundedIdentifierSchema.optional(),
+});
+export const AgentEnvironmentStatusSchema = z.enum([
+    "pending",
+    "provisioning",
+    "running",
+    "stopped",
+    "failed",
+    "expired",
+    "unknown",
+]);
+/** Lifecycle, cleanup, continuity, and persistence of one environment. */
+export const EnvironmentLifecycleSchema = z.strictObject({
+    status: AgentEnvironmentStatusSchema,
+    cleanup: z
+        .strictObject({
+        policy: z.enum(["manual", "idle", "scheduled", "on-exit"]).optional(),
+        scheduledAt: z.iso.datetime().max(64).optional(),
+        confirmed: z.boolean().optional(),
+    })
+        .optional(),
+    continuity: z
+        .strictObject({
+        resumable: z.boolean(),
+        mode: z.enum(["native", "replayed", "none"]).optional(),
+    })
+        .optional(),
+    persistence: z
+        .strictObject({
+        durable: z.boolean(),
+        scope: z.enum(["ephemeral", "session", "durable"]).optional(),
+    })
+        .optional(),
+});
+/**
+ * Credential-free network location. There is no field for a user, password,
+ * token, or other secret, and the host and scheme reject embedded credentials.
+ */
+export const SafeEndpointSchema = z
+    .strictObject({
+    scheme: boundedIdentifierSchema.optional(),
+    host: boundedIdentifierSchema,
+    port: z.number().int().min(1).max(65_535).optional(),
+    region: boundedIdentifierSchema.optional(),
+})
+    .superRefine((endpoint, refinement) => {
+    if (/[@/\s]|:\/\//.test(endpoint.host)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["host"],
+            message: "endpoint host must not carry credentials, a scheme, or a path",
+        });
+    }
+    if (endpoint.scheme !== undefined && /[@:/\s]/.test(endpoint.scheme)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["scheme"],
+            message: "endpoint scheme must be a bare protocol name",
+        });
+    }
+});
+/** Requested or effective compute shape, including an optional accelerator. */
+export const ResourceProfileSchema = z.strictObject({
+    cpu: z.number().finite().positive().optional(),
+    memoryMb: z.number().int().positive().optional(),
+    diskMb: z.number().int().positive().optional(),
+    accelerator: z
+        .strictObject({
+        kind: boundedIdentifierSchema,
+        count: z.number().int().positive(),
+        memoryMb: z.number().int().positive().optional(),
+    })
+        .optional(),
+});
+/** A point-in-time or peak resource sample. */
+export const ResourceUseSampleSchema = z.strictObject({
+    cpu: nonNegativeNumberSchema.optional(),
+    memoryMb: nonNegativeNumberSchema.optional(),
+    diskMb: nonNegativeNumberSchema.optional(),
+    acceleratorMemoryMb: nonNegativeNumberSchema.optional(),
+});
+/** Where an environment was requested or verified to run. */
+export const PlacementDescriptorSchema = z.strictObject({
+    kind: z.enum(["local", "sandbox", "fleet", "provider"]),
+    sandboxId: boundedIdentifierSchema.optional(),
+    fleetId: boundedIdentifierSchema.optional(),
+    machineId: boundedIdentifierSchema.optional(),
+    region: boundedIdentifierSchema.optional(),
+});
+/**
+ * Token usage and cost for one execution. Bound to the shared {@link TokenUsage}
+ * type so a change to the canonical shape is caught here.
+ */
+export const ModelUsageSchema = z.strictObject({
+    inputTokens: z.number().int().nonnegative(),
+    outputTokens: z.number().int().nonnegative(),
+    totalTokens: z.number().int().nonnegative().optional(),
+    cacheReadInputTokens: z.number().int().nonnegative().optional(),
+    cacheCreationInputTokens: z.number().int().nonnegative().optional(),
+    reasoningTokens: z.number().int().nonnegative().optional(),
+    cost: z.number().finite().nonnegative().optional(),
+});
+/** Provider compute cost charged for one environment. */
+export const ComputeBillingSchema = z.strictObject({
+    amount: nonNegativeNumberSchema,
+    currency: boundedIdentifierSchema,
+});
+/** Account plan, credits, quota, and billing period. */
+export const AccountUsageSchema = z.strictObject({
+    plan: observationOf(boundedIdentifierSchema).optional(),
+    credits: observationOf(z.strictObject({
+        remaining: nonNegativeNumberSchema,
+        unit: boundedIdentifierSchema,
+    })).optional(),
+    quota: observationOf(z.strictObject({
+        limit: nonNegativeNumberSchema,
+        used: nonNegativeNumberSchema,
+        remaining: nonNegativeNumberSchema,
+        unit: boundedIdentifierSchema,
+    })).optional(),
+    period: observationOf(z.strictObject({
+        start: z.iso.datetime().max(64),
+        end: z.iso.datetime().max(64),
+    })).optional(),
+});
+/**
+ * Optional normalized observation of one execution environment.
+ *
+ * `subject` is the always-known identity used to bind a live observation to its
+ * replay. Every other surface is optional and freshness-tagged, so a provider
+ * that reports nothing still validates and no absent value is a measured zero.
+ */
+export const AgentEnvironmentObservationSchema = z.strictObject({
+    subject: ProviderIdentitySchema,
+    capturedAt: z.iso.datetime().max(64),
+    identity: observationOf(ProviderIdentitySchema).optional(),
+    lifecycle: observationOf(EnvironmentLifecycleSchema).optional(),
+    endpoint: observationOf(SafeEndpointSchema).optional(),
+    placement: z
+        .strictObject({
+        requested: PlacementDescriptorSchema.optional(),
+        verified: observationOf(PlacementDescriptorSchema).optional(),
+    })
+        .optional(),
+    resources: z
+        .strictObject({
+        requested: ResourceProfileSchema.optional(),
+        effective: observationOf(ResourceProfileSchema).optional(),
+    })
+        .optional(),
+    resourceUse: z
+        .strictObject({
+        current: observationOf(ResourceUseSampleSchema).optional(),
+        peak: observationOf(ResourceUseSampleSchema).optional(),
+    })
+        .optional(),
+    modelUsage: observationOf(ModelUsageSchema).optional(),
+    computeBilling: observationOf(ComputeBillingSchema).optional(),
+    accountUsage: AccountUsageSchema.optional(),
+});
+function providerIdentityEquals(left, right) {
+    return (left.provider === right.provider &&
+        left.environmentId === right.environmentId &&
+        left.sessionId === right.sessionId &&
+        left.backend === right.backend);
+}
+function observedIdentityMatches(left, right) {
+    if (left === undefined && right === undefined)
+        return true;
+    if (left === undefined || right === undefined)
+        return false;
+    if (left.state !== right.state)
+        return false;
+    const leftValue = "value" in left ? left.value : undefined;
+    const rightValue = "value" in right ? right.value : undefined;
+    if (leftValue === undefined && rightValue === undefined)
+        return true;
+    if (leftValue === undefined || rightValue === undefined)
+        return false;
+    const leftSource = "provenance" in left ? left.provenance.source : undefined;
+    const rightSource = "provenance" in right ? right.provenance.source : undefined;
+    return providerIdentityEquals(leftValue, rightValue) && leftSource === rightSource;
+}
+/**
+ * A live observation and its replay must name the same environment and the
+ * same observed identity and provenance source. Time and freshness may differ,
+ * but the identifiers may not.
+ */
+export function agentEnvironmentObservationIdentityMatches(live, replay) {
+    const parsedLive = AgentEnvironmentObservationSchema.safeParse(live);
+    const parsedReplay = AgentEnvironmentObservationSchema.safeParse(replay);
+    if (!parsedLive.success || !parsedReplay.success)
+        return false;
+    return (providerIdentityEquals(parsedLive.data.subject, parsedReplay.data.subject) &&
+        observedIdentityMatches(parsedLive.data.identity, parsedReplay.data.identity));
+}
+const USERINFO_URL_PATTERN = /[a-z][a-z0-9+.-]*:\/\/[^/@\s]*@/i;
+/**
+ * Secret-shaped whole words. Matching whole words, not substrings, keeps a
+ * token-count field such as `inputTokens` from reading as an auth token.
+ */
+const CREDENTIAL_WORDS = new Set([
+    "token",
+    "secret",
+    "secrets",
+    "password",
+    "passwd",
+    "passphrase",
+    "credential",
+    "credentials",
+    "authorization",
+    "bearer",
+    "key",
+    "keys",
+]);
+/** Split a key into lowercase words across camelCase and separators. */
+function keyWords(key) {
+    return key
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .split(/[^a-zA-Z0-9]+/)
+        .map((word) => word.toLowerCase())
+        .filter(Boolean);
+}
+/**
+ * Report whether an observation payload carries a credential. A credential is a
+ * secret-shaped object key or a string value with embedded userinfo. Contract
+ * tests use this to prove the observation surface never transports a secret.
+ */
+export function observationContainsCredential(value) {
+    const pending = [value];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (typeof current === "string") {
+            if (USERINFO_URL_PATTERN.test(current))
+                return true;
+            continue;
+        }
+        if (current === null || typeof current !== "object")
+            continue;
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        if (Array.isArray(current)) {
+            for (const item of current)
+                pending.push(item);
+            continue;
+        }
+        for (const [key, entry] of Object.entries(current)) {
+            if (keyWords(key).some((word) => CREDENTIAL_WORDS.has(word)))
+                return true;
+            pending.push(entry);
+        }
+    }
+    return false;
+}
+/** Throw when an observation payload carries a credential. */
+export function assertObservationCredentialFree(value) {
+    if (observationContainsCredential(value)) {
+        throw new Error("observation payload must not carry a credential");
+    }
+}

package/dist/environment-provider.d.ts

@@ -1,3 +1,5 @@
 export * from "./environment-requests.js";
 export * from "./environment-exact-process.js";
+export * from "./environment-observation.js";
+export * from "./environment-terminal.js";
 export * from "./environment-runtime.js";

package/dist/environment-provider.js

@@ -1,3 +1,5 @@
 export * from "./environment-requests.js";
 export * from "./environment-exact-process.js";
+export * from "./environment-observation.js";
+export * from "./environment-terminal.js";
 export * from "./environment-runtime.js";

package/dist/environment-runtime.d.ts

@@ -9,6 +9,8 @@ import { type AgentRunCancellationAcknowledgement, type AgentRunCancellationRequ
 import type { AgentWorkspaceBranching } from "./workspace-branching.js";
 import type { AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSessionStatus, CheckpointRef, CheckpointRequest, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from "./environment-requests.js";
 import type { AgentExactProcessEgressMode, AgentExactProcessProvider } from "./environment-exact-process.js";
+import type { AgentEnvironmentObservation } from "./environment-observation.js";
+import type { AgentTerminalSession, TerminalAttachRequest, TerminalAttachResult } from "./environment-terminal.js";
 export interface AgentTurnInput {
     prompt?: string;
     parts?: InputPart[];
@@ -653,6 +655,18 @@ export interface AgentEnvironment {
     placement?(options?: {
         signal?: AbortSignal;
     }): Promise<PlacementInfo>;
+    /** Normalized, freshness-tagged observation of this environment. */
+    observe?(options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentEnvironmentObservation>;
+    /** Open or reattach an interactive terminal under a parent execution. */
+    attachTerminal?(request: TerminalAttachRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<TerminalAttachResult>;
+    /** Accessor for a live interactive terminal handle. */
+    terminal?(terminalSessionId: string, options?: {
+        signal?: AbortSignal;
+    }): AgentTerminalSession;
     refresh?(options?: {
         signal?: AbortSignal;
     }): Promise<void>;
@@ -712,6 +726,25 @@ export interface AgentEnvironmentCapabilities {
     exactProcess?: {
         egress: readonly AgentExactProcessEgressMode[];
     };
+    /** Per-surface flags for the normalized environment observation. */
+    observation?: {
+        identity: boolean;
+        lifecycle: boolean;
+        endpoint: boolean;
+        placement: boolean;
+        resources: boolean;
+        resourceUse: boolean;
+        modelUsage: boolean;
+        computeBilling: boolean;
+        accountUsage: boolean;
+    };
+    /** Present only when the provider serves an interactive terminal. */
+    interactiveTerminal?: {
+        attach: boolean;
+        input: boolean;
+        resize: boolean;
+        reattach: boolean;
+    };
 }
 /** Strict runtime validator for provider capability negotiation. */
 export declare const AgentEnvironmentCapabilitiesSchema: z.ZodObject<{
@@ -804,6 +837,23 @@ export declare const AgentEnvironmentCapabilitiesSchema: z.ZodObject<{
             strict: "strict";
         }>>;
     }, z.core.$strict>>;
+    observation: z.ZodOptional<z.ZodObject<{
+        identity: z.ZodBoolean;
+        lifecycle: z.ZodBoolean;
+        endpoint: z.ZodBoolean;
+        placement: z.ZodBoolean;
+        resources: z.ZodBoolean;
+        resourceUse: z.ZodBoolean;
+        modelUsage: z.ZodBoolean;
+        computeBilling: z.ZodBoolean;
+        accountUsage: z.ZodBoolean;
+    }, z.core.$strict>>;
+    interactiveTerminal: z.ZodOptional<z.ZodObject<{
+        attach: z.ZodBoolean;
+        input: z.ZodBoolean;
+        resize: z.ZodBoolean;
+        reattach: z.ZodBoolean;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export interface CreateAgentEnvironmentInput {
     profile: AgentProfileRef;

package/dist/environment-runtime.js

@@ -167,6 +167,27 @@ export const AgentEnvironmentCapabilitiesSchema = z
             .max(CONTRACT_MAX_ARRAY_LENGTH),
     })
         .optional(),
+    observation: z
+        .strictObject({
+        identity: z.boolean(),
+        lifecycle: z.boolean(),
+        endpoint: z.boolean(),
+        placement: z.boolean(),
+        resources: z.boolean(),
+        resourceUse: z.boolean(),
+        modelUsage: z.boolean(),
+        computeBilling: z.boolean(),
+        accountUsage: z.boolean(),
+    })
+        .optional(),
+    interactiveTerminal: z
+        .strictObject({
+        attach: z.boolean(),
+        input: z.boolean(),
+        resize: z.boolean(),
+        reattach: z.boolean(),
+    })
+        .optional(),
 })
     .superRefine((capabilities, refinement) => {
     if (capabilities.retainedControl !== undefined &&
@@ -217,6 +238,16 @@ export const AgentEnvironmentCapabilitiesSchema = z
             message: "exact process egress modes must be unique",
         });
     }
+    const terminal = capabilities.interactiveTerminal;
+    if (terminal !== undefined &&
+        (terminal.input || terminal.resize || terminal.reattach) &&
+        !terminal.attach) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["interactiveTerminal"],
+            message: "interactive terminal input, resize, and reattach each require attach",
+        });
+    }
     const extensions = capabilities.profile.extensions;
     if (extensions && new Set(extensions).size !== extensions.length) {
         refinement.addIssue({

package/dist/environment-terminal.d.ts

@@ -0,0 +1,172 @@
+import { z } from "zod";
+/**
+ * Provider-neutral handle for one interactive terminal.
+ *
+ * The handle carries no raw process id and no environment map, so a terminal
+ * reference never leaks host process detail or injected secrets. Every terminal
+ * is bound to a parent execution and carries an explicit expiry, so an orphan
+ * or an expired terminal fails closed at the call sites that read it.
+ */
+export declare const TerminalSessionRefSchema: z.ZodObject<{
+    terminalSessionId: z.ZodString;
+    parentExecutionId: z.ZodString;
+    name: z.ZodString;
+    shell: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodString;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+    connectionId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    lastActivityAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    isRunning: z.ZodBoolean;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    exitSignal: z.ZodOptional<z.ZodString>;
+    attachCount: z.ZodNumber;
+}, z.core.$strict>;
+export type TerminalSessionRef = z.infer<typeof TerminalSessionRefSchema>;
+/** Raw bytes written to the terminal, normalized to UTF-8 text. */
+export declare const TerminalInputSchema: z.ZodObject<{
+    data: z.ZodString;
+}, z.core.$strict>;
+export type TerminalInput = z.infer<typeof TerminalInputSchema>;
+/** New terminal geometry. */
+export declare const TerminalResizeSchema: z.ZodObject<{
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+}, z.core.$strict>;
+export type TerminalResize = z.infer<typeof TerminalResizeSchema>;
+/**
+ * Create-or-reattach request. A present `terminalSessionId` reattaches to an
+ * existing terminal; its absence opens a new one under the parent execution.
+ * `mode` selects an `attach` to a live process or a `logical` resume that
+ * replays retained output.
+ */
+export declare const TerminalAttachRequestSchema: z.ZodObject<{
+    parentExecutionId: z.ZodString;
+    terminalSessionId: z.ZodOptional<z.ZodString>;
+    connectionId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodEnum<{
+        attach: "attach";
+        logical: "logical";
+    }>;
+    cols: z.ZodOptional<z.ZodNumber>;
+    rows: z.ZodOptional<z.ZodNumber>;
+    command: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TerminalAttachRequest = z.infer<typeof TerminalAttachRequestSchema>;
+/** Result of a create-or-reattach request. */
+export declare const TerminalAttachResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodEnum<{
+        attached: "attached";
+        reattached: "reattached";
+    }>;
+    mode: z.ZodEnum<{
+        attach: "attach";
+        logical: "logical";
+    }>;
+    ref: z.ZodObject<{
+        terminalSessionId: z.ZodString;
+        parentExecutionId: z.ZodString;
+        name: z.ZodString;
+        shell: z.ZodString;
+        command: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodString;
+        cols: z.ZodNumber;
+        rows: z.ZodNumber;
+        connectionId: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        lastActivityAt: z.ZodISODateTime;
+        expiresAt: z.ZodISODateTime;
+        isRunning: z.ZodBoolean;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        exitSignal: z.ZodOptional<z.ZodString>;
+        attachCount: z.ZodNumber;
+    }, z.core.$strict>;
+    attachCount: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"unknown">;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+}, z.core.$strict>], "status">;
+export type TerminalAttachResult = z.infer<typeof TerminalAttachResultSchema>;
+/**
+ * One ordered terminal output frame. `output` frames carry a monotonic `seq`
+ * that a consumer replays from, so a reconnect resumes without loss or
+ * duplication.
+ */
+export declare const TerminalOutputEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"ready">;
+    cols: z.ZodOptional<z.ZodNumber>;
+    rows: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"output">;
+    seq: z.ZodNumber;
+    data: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"resize">;
+    cols: z.ZodNumber;
+    rows: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"exit">;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    exitSignal: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, z.core.$strict>], "type">;
+export type TerminalOutputEvent = z.infer<typeof TerminalOutputEventSchema>;
+/** Acknowledgement of a detach or close. */
+export declare const TerminalDetachAckSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"detached">;
+    terminalSessionId: z.ZodString;
+    connectionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"closed">;
+    terminalSessionId: z.ZodString;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    exitSignal: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"unknown">;
+    terminalSessionId: z.ZodString;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+}, z.core.$strict>], "status">;
+export type TerminalDetachAck = z.infer<typeof TerminalDetachAckSchema>;
+/**
+ * Fail-closed usability check for a terminal reference. Returns true only when
+ * the reference parses, is running, and its expiry is in the future. A parse
+ * failure, a stopped terminal, or a past expiry denies use.
+ */
+export declare function terminalSessionUsable(ref: TerminalSessionRef, nowIso: string): boolean;
+/** Bind an attach result to the parent execution and terminal it targeted. */
+export declare function terminalAttachResultMatchesRequest(request: TerminalAttachRequest, result: TerminalAttachResult): boolean;
+/**
+ * Live handle for one interactive terminal. Signatures only; a provider adapter
+ * binds the transport in phase two.
+ */
+export interface AgentTerminalSession {
+    readonly ref: TerminalSessionRef;
+    input(input: TerminalInput, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    resize(resize: TerminalResize, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    detach(options?: {
+        signal?: AbortSignal;
+    }): Promise<TerminalDetachAck>;
+    close(options?: {
+        signal?: AbortSignal;
+    }): Promise<TerminalDetachAck>;
+    /** Replays retained frames from `since`, then continues until the terminal exits. */
+    events(options?: {
+        since?: number;
+        signal?: AbortSignal;
+    }): AsyncIterable<TerminalOutputEvent>;
+}