@tangle-network/agent-interface 0.44.0 → 0.46.0

package/dist/agent-candidate-schema-common.js

@@ -221,7 +221,7 @@ function configRecordSchema(keySchema) {
     return z
         .record(keySchema, agentCandidateConfigValueSchema)
         .superRefine((config, ctx) => {
-        for (const [name, value] of Object.entries(config)) {
+        for (const name of Object.keys(config)) {
             if (secretNamePattern.test(name)) {
                 ctx.addIssue({
                     code: "custom",

package/dist/agent-candidate-schema.d.ts

@@ -41,6 +41,7 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
             opencode: "opencode";
             "kimi-code": "kimi-code";
             pi: "pi";
+            prime: "prime";
             gemini: "gemini";
             hermes: "hermes";
             openclaw: "openclaw";
@@ -60,9 +61,9 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
         mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./agent-candidate.js").AgentCandidateMcpServer, unknown, z.core.$ZodTypeInternals<import("./agent-candidate.js").AgentCandidateMcpServer, unknown>>>>;
         subagents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             prompt: z.ZodOptional<z.ZodString>;
-            permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
             tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
             description: z.ZodOptional<z.ZodString>;
+            permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
             model: z.ZodOptional<z.ZodString>;
             maxSteps: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>>;
@@ -539,9 +540,9 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
         }, z.core.$strict>>>>;
         modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             prompt: z.ZodOptional<z.ZodString>;
-            permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
             tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
             description: z.ZodOptional<z.ZodString>;
+            permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
             model: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
         confidential: z.ZodOptional<z.ZodObject<{
@@ -591,6 +592,7 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
             opencode: "opencode";
             "kimi-code": "kimi-code";
             pi: "pi";
+            prime: "prime";
             gemini: "gemini";
             hermes: "hermes";
             openclaw: "openclaw";

package/dist/agent-execution-preparation.d.ts

@@ -148,27 +148,27 @@ export type AgentExecutionPreparationValidationResult = {
 };
 export declare const agentExecutionPreparationAxisResultSchema: z.ZodObject<{
     axis: z.ZodEnum<{
-        permissions: "permissions";
+        name: "name";
+        systemPrompt: "systemPrompt";
+        appendSystemPrompt: "appendSystemPrompt";
+        instructions: "instructions";
+        files: "files";
         tools: "tools";
+        skills: "skills";
+        commands: "commands";
+        description: "description";
+        version: "version";
+        tags: "tags";
+        harness: "harness";
+        permissions: "permissions";
         mcp: "mcp";
         connections: "connections";
         subagents: "subagents";
         hooks: "hooks";
         modes: "modes";
-        metadata: "metadata";
-        description: "description";
-        name: "name";
-        files: "files";
-        version: "version";
-        tags: "tags";
-        harness: "harness";
         confidential: "confidential";
+        metadata: "metadata";
         extensions: "extensions";
-        systemPrompt: "systemPrompt";
-        appendSystemPrompt: "appendSystemPrompt";
-        instructions: "instructions";
-        skills: "skills";
-        commands: "commands";
         modelDefault: "modelDefault";
         modelSmall: "modelSmall";
         modelProvider: "modelProvider";
@@ -234,6 +234,7 @@ export declare const agentExecutionPreparationReceiptSchema: z.ZodObject<{
         opencode: "opencode";
         "kimi-code": "kimi-code";
         pi: "pi";
+        prime: "prime";
         gemini: "gemini";
         hermes: "hermes";
         openclaw: "openclaw";
@@ -295,27 +296,27 @@ export declare const agentExecutionPreparationReceiptSchema: z.ZodObject<{
     }, z.core.$strict>;
     axisResults: z.ZodArray<z.ZodObject<{
         axis: z.ZodEnum<{
-            permissions: "permissions";
+            name: "name";
+            systemPrompt: "systemPrompt";
+            appendSystemPrompt: "appendSystemPrompt";
+            instructions: "instructions";
+            files: "files";
             tools: "tools";
+            skills: "skills";
+            commands: "commands";
+            description: "description";
+            version: "version";
+            tags: "tags";
+            harness: "harness";
+            permissions: "permissions";
             mcp: "mcp";
             connections: "connections";
             subagents: "subagents";
             hooks: "hooks";
             modes: "modes";
-            metadata: "metadata";
-            description: "description";
-            name: "name";
-            files: "files";
-            version: "version";
-            tags: "tags";
-            harness: "harness";
             confidential: "confidential";
+            metadata: "metadata";
             extensions: "extensions";
-            systemPrompt: "systemPrompt";
-            appendSystemPrompt: "appendSystemPrompt";
-            instructions: "instructions";
-            skills: "skills";
-            commands: "commands";
             modelDefault: "modelDefault";
             modelSmall: "modelSmall";
             modelProvider: "modelProvider";

package/dist/agent-profile.d.ts

@@ -442,9 +442,16 @@ export interface AgentProfileValidationResult {
 /**
  * Merge two public AgentProfile values.
  *
- * Overlay fields win on conflicts. Additive fields compose instead: array-like
- * instruction sets are concatenated, and `prompt.appendSystemPrompt` values are
- * joined base-first with a blank line between them.
+ * Overlay fields win on conflicts, but only where they carry a value: an
+ * `undefined` entry reads as "not specified" and keeps the base value, because
+ * removal is the `remove` channel's job on {@link AgentProfileDiff}. Keys that
+ * resolve to nothing are omitted rather than written as `undefined` — RFC 8785
+ * canonicalization enumerates own keys, so a present-but-undefined key is a
+ * different document from an absent one.
+ *
+ * Additive fields compose instead of overwriting: array-like instruction sets
+ * are concatenated, and `prompt.appendSystemPrompt` values are joined
+ * base-first with a blank line between them.
  */
 export declare function mergeAgentProfiles(base: AgentProfile | undefined, overlay: AgentProfile | undefined): AgentProfile | undefined;
 export {};

package/dist/agent-profile.js

@@ -23,10 +23,12 @@ export function defineInlineResource(name, content) {
 export function defineGitHubResource(path, options = {}) {
     return {
         kind: "github",
-        repository: options.repository,
         path,
-        ref: options.ref,
-        name: options.name,
+        ...(options.repository === undefined
+            ? {}
+            : { repository: options.repository }),
+        ...(options.ref === undefined ? {} : { ref: options.ref }),
+        ...(options.name === undefined ? {} : { name: options.name }),
     };
 }
 /**
@@ -67,6 +69,29 @@ export function defineAgentProfileSecretRef(key, format) {
 export function defineAgentProfile(profile) {
     return profile;
 }
+/**
+ * Layer objects the way a spread would, except that an `undefined` entry means
+ * "not specified" and is never written to the result.
+ *
+ * Profile identity is an RFC 8785 digest over the profile, and canonicalization
+ * enumerates own keys: `{ tools: undefined }` is a different document from `{}`,
+ * so writing a key with no value moves the digest of a profile whose content did
+ * not change, or is refused outright by the canonical JSON domain. Later sources
+ * therefore win only where they carry a value; removal is expressed through
+ * {@link AgentProfileDiff}'s `remove` channel, never by overlaying `undefined`.
+ */
+function assignDefined(...sources) {
+    const merged = {};
+    for (const source of sources) {
+        if (source === undefined)
+            continue;
+        for (const [key, value] of Object.entries(source)) {
+            if (value !== undefined)
+                merged[key] = value;
+        }
+    }
+    return merged;
+}
 function mergeStringArrays(base, overlay) {
     if (!base && !overlay)
         return undefined;
@@ -88,10 +113,7 @@ function mergeAppendedSystemPrompts(base, overlay) {
 function mergeRecord(base, overlay) {
     if (!base && !overlay)
         return undefined;
-    return {
-        ...(base ?? {}),
-        ...(overlay ?? {}),
-    };
+    return assignDefined(base, overlay);
 }
 function mergeOptionalArrays(base, overlay) {
     if (!base && !overlay)
@@ -101,36 +123,37 @@ function mergeOptionalArrays(base, overlay) {
 /**
  * Merge two public AgentProfile values.
  *
- * Overlay fields win on conflicts. Additive fields compose instead: array-like
- * instruction sets are concatenated, and `prompt.appendSystemPrompt` values are
- * joined base-first with a blank line between them.
+ * Overlay fields win on conflicts, but only where they carry a value: an
+ * `undefined` entry reads as "not specified" and keeps the base value, because
+ * removal is the `remove` channel's job on {@link AgentProfileDiff}. Keys that
+ * resolve to nothing are omitted rather than written as `undefined` — RFC 8785
+ * canonicalization enumerates own keys, so a present-but-undefined key is a
+ * different document from an absent one.
+ *
+ * Additive fields compose instead of overwriting: array-like instruction sets
+ * are concatenated, and `prompt.appendSystemPrompt` values are joined
+ * base-first with a blank line between them.
  */
 export function mergeAgentProfiles(base, overlay) {
     if (!base && !overlay)
         return undefined;
     const mergedPrompt = base?.prompt || overlay?.prompt
-        ? {
-            ...(base?.prompt ?? {}),
-            ...(overlay?.prompt ?? {}),
+        ? assignDefined(base?.prompt, overlay?.prompt, {
             appendSystemPrompt: mergeAppendedSystemPrompts(base?.prompt?.appendSystemPrompt, overlay?.prompt?.appendSystemPrompt),
             instructions: mergeStringArrays(base?.prompt?.instructions, overlay?.prompt?.instructions),
-        }
+        })
         : undefined;
     const mergedResources = base?.resources || overlay?.resources
-        ? {
-            ...(base?.resources ?? {}),
-            ...(overlay?.resources ?? {}),
+        ? assignDefined(base?.resources, overlay?.resources, {
             files: mergeOptionalArrays(base?.resources?.files, overlay?.resources?.files),
             tools: mergeOptionalArrays(base?.resources?.tools, overlay?.resources?.tools),
             skills: mergeOptionalArrays(base?.resources?.skills, overlay?.resources?.skills),
             agents: mergeOptionalArrays(base?.resources?.agents, overlay?.resources?.agents),
             commands: mergeOptionalArrays(base?.resources?.commands, overlay?.resources?.commands),
             instructions: overlay?.resources?.instructions ?? base?.resources?.instructions,
-        }
+        })
         : undefined;
-    return {
-        ...(base ?? {}),
-        ...(overlay ?? {}),
+    return assignDefined(base, overlay, {
         prompt: mergedPrompt,
         permissions: mergeRecord(base?.permissions, overlay?.permissions),
         tools: mergeRecord(base?.tools, overlay?.tools),
@@ -142,5 +165,5 @@ export function mergeAgentProfiles(base, overlay) {
         modes: mergeRecord(base?.modes, overlay?.modes),
         metadata: mergeRecord(base?.metadata, overlay?.metadata),
         extensions: mergeRecord(base?.extensions, overlay?.extensions),
-    };
+    });
 }

package/dist/backend-message.d.ts

@@ -0,0 +1,14 @@
+import type { InputPart, Part } from "./parts.js";
+export type BackendMessage = {
+    id: string;
+    role: "user" | "assistant" | "system";
+    parts: Array<Part | InputPart | unknown>;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+};
+export type GetMessagesOptions = {
+    sessionId: string;
+    limit?: number;
+    offset?: number;
+    since?: number;
+};

package/dist/backend-message.js

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

package/dist/contract-limits.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+/** Limits applied before a value is hashed, copied, or sent to a provider. */
+export declare const CONTRACT_MAX_STRING_LENGTH = 16384;
+export declare const CONTRACT_MAX_IDENTIFIER_LENGTH = 512;
+export declare const CONTRACT_MAX_ARRAY_LENGTH = 1024;
+export declare const CONTRACT_MAX_MAP_ENTRIES = 256;
+export declare const CONTRACT_MAX_JSON_DEPTH = 16;
+export declare const CONTRACT_MAX_JSON_BYTES = 1048576;
+export declare const CONTRACT_MAX_JSON_NODES = 8192;
+export declare const boundedStringSchema: z.ZodString;
+export declare const boundedIdentifierSchema: z.ZodString;
+/**
+ * Validate JSON without asking Zod to recursively copy an attacker-sized
+ * value. This is intentionally iterative so depth and collection limits are
+ * checked before canonical serialization.
+ */
+export declare function isBoundedJsonValue(value: unknown): boolean;
+/** Validate digest input while matching JSON's omission of undefined object fields. */
+export declare function isBoundedJsonMaterial(value: unknown): boolean;
+export declare const boundedJsonSchema: z.ZodCustom<unknown, unknown>;
+export declare const boundedJsonRecordSchema: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+export declare function assertBoundedJson(value: unknown): void;
+export declare function assertBoundedSerializedJson(value: string): void;
+/** Copy arbitrary metadata into a map that cannot inherit prototype keys. */
+export declare function nullPrototypeRecord<T>(value: Record<string, T>): Record<string, T>;
+export declare function hasOwn(value: object, key: PropertyKey): boolean;

package/dist/contract-limits.js

@@ -0,0 +1,175 @@
+import { z } from "zod";
+/** Limits applied before a value is hashed, copied, or sent to a provider. */
+export const CONTRACT_MAX_STRING_LENGTH = 16_384;
+export const CONTRACT_MAX_IDENTIFIER_LENGTH = 512;
+export const CONTRACT_MAX_ARRAY_LENGTH = 1_024;
+export const CONTRACT_MAX_MAP_ENTRIES = 256;
+export const CONTRACT_MAX_JSON_DEPTH = 16;
+export const CONTRACT_MAX_JSON_BYTES = 1_048_576;
+export const CONTRACT_MAX_JSON_NODES = 8_192;
+export const boundedStringSchema = z.string().max(CONTRACT_MAX_STRING_LENGTH);
+export const boundedIdentifierSchema = boundedStringSchema
+    .min(1)
+    .max(CONTRACT_MAX_IDENTIFIER_LENGTH)
+    .refine((value) => value.trim() === value, "identifier cannot have outer whitespace");
+/**
+ * Validate JSON without asking Zod to recursively copy an attacker-sized
+ * value. This is intentionally iterative so depth and collection limits are
+ * checked before canonical serialization.
+ */
+export function isBoundedJsonValue(value) {
+    const pending = [{ value, depth: 0 }];
+    const ancestors = new Set();
+    let nodes = 0;
+    while (pending.length > 0) {
+        const item = pending.pop();
+        if (!item)
+            continue;
+        nodes += 1;
+        if (nodes > CONTRACT_MAX_JSON_NODES)
+            return false;
+        const current = item.value;
+        if (item.leave) {
+            ancestors.delete(current);
+            continue;
+        }
+        if (current === undefined)
+            return false;
+        if (current === null || typeof current === "boolean")
+            continue;
+        if (typeof current === "string") {
+            if (current.length > CONTRACT_MAX_STRING_LENGTH)
+                return false;
+            continue;
+        }
+        if (typeof current === "number") {
+            if (!Number.isFinite(current))
+                return false;
+            continue;
+        }
+        if (typeof current !== "object" || item.depth >= CONTRACT_MAX_JSON_DEPTH) {
+            return false;
+        }
+        if (ancestors.has(current))
+            return false;
+        ancestors.add(current);
+        pending.push({ value: current, depth: item.depth, leave: true });
+        if (Array.isArray(current)) {
+            if (current.length > CONTRACT_MAX_ARRAY_LENGTH)
+                return false;
+            for (const entry of current) {
+                pending.push({ value: entry, depth: item.depth + 1 });
+            }
+            continue;
+        }
+        const prototype = Object.getPrototypeOf(current);
+        if (prototype !== Object.prototype && prototype !== null)
+            return false;
+        const keys = Object.keys(current);
+        if (keys.length > CONTRACT_MAX_MAP_ENTRIES)
+            return false;
+        for (const key of keys) {
+            if (key.length > CONTRACT_MAX_IDENTIFIER_LENGTH)
+                return false;
+            pending.push({
+                value: current[key],
+                depth: item.depth + 1,
+            });
+        }
+    }
+    return true;
+}
+/** Validate digest input while matching JSON's omission of undefined object fields. */
+export function isBoundedJsonMaterial(value) {
+    const pending = [{ value, depth: 0 }];
+    const ancestors = new Set();
+    let nodes = 0;
+    while (pending.length > 0) {
+        const item = pending.pop();
+        if (!item)
+            continue;
+        if (item.leave) {
+            ancestors.delete(item.value);
+            continue;
+        }
+        if (item.value === undefined) {
+            if (item.omitUndefined === true)
+                continue;
+            return false;
+        }
+        nodes += 1;
+        if (nodes > CONTRACT_MAX_JSON_NODES)
+            return false;
+        const current = item.value;
+        if (current === null || typeof current === "boolean")
+            continue;
+        if (typeof current === "string") {
+            if (current.length > CONTRACT_MAX_STRING_LENGTH)
+                return false;
+            continue;
+        }
+        if (typeof current === "number") {
+            if (!Number.isFinite(current))
+                return false;
+            continue;
+        }
+        if (typeof current !== "object" || item.depth >= CONTRACT_MAX_JSON_DEPTH) {
+            return false;
+        }
+        if (ancestors.has(current))
+            return false;
+        ancestors.add(current);
+        pending.push({ value: current, depth: item.depth, leave: true });
+        if (Array.isArray(current)) {
+            if (current.length > CONTRACT_MAX_ARRAY_LENGTH)
+                return false;
+            for (const entry of current) {
+                pending.push({ value: entry, depth: item.depth + 1 });
+            }
+            continue;
+        }
+        const prototype = Object.getPrototypeOf(current);
+        if (prototype !== Object.prototype && prototype !== null)
+            return false;
+        const keys = Object.keys(current);
+        if (keys.length > CONTRACT_MAX_MAP_ENTRIES)
+            return false;
+        for (const key of keys) {
+            if (key.length > CONTRACT_MAX_IDENTIFIER_LENGTH)
+                return false;
+            pending.push({
+                value: current[key],
+                depth: item.depth + 1,
+                omitUndefined: true,
+            });
+        }
+    }
+    return true;
+}
+export const boundedJsonSchema = z.custom(isBoundedJsonValue, {
+    message: "value exceeds the contract bounds or is not finite JSON",
+});
+export const boundedJsonRecordSchema = z.custom((value) => typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    isBoundedJsonValue(value), { message: "metadata exceeds the contract bounds or is not a JSON object" });
+export function assertBoundedJson(value) {
+    if (!isBoundedJsonValue(value)) {
+        throw new Error("value exceeds the contract bounds or is not finite JSON");
+    }
+}
+export function assertBoundedSerializedJson(value) {
+    if (new TextEncoder().encode(value).byteLength > CONTRACT_MAX_JSON_BYTES) {
+        throw new Error("serialized contract material exceeds its byte bound");
+    }
+}
+/** Copy arbitrary metadata into a map that cannot inherit prototype keys. */
+export function nullPrototypeRecord(value) {
+    const result = Object.create(null);
+    for (const key of Object.keys(value))
+        result[key] = value[key];
+    return result;
+}
+export function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}

package/dist/environment-exact-process.d.ts

@@ -0,0 +1,161 @@
+import type { AgentCandidateTermination } from "./agent-candidate.js";
+export type AgentExactProcessEgressMode = "blocked" | "strict";
+/**
+ * Outbound network policy for an exact process environment. `blocked` denies
+ * every protocol. `strict` permits only the named domains; direct-address,
+ * alternate-protocol, and cross-environment bypasses must fail.
+ */
+export type AgentExactProcessEgressPolicy = {
+    mode: "blocked";
+} | {
+    mode: "strict";
+    allowDomains: readonly string[];
+};
+/** Explicit portable limits for an exact process environment. */
+export interface AgentExactProcessResources {
+    /** Positive CPU core count. */
+    cpu: number;
+    /** Positive integer mebibytes of memory. */
+    memoryMb: number;
+    /** Positive integer mebibytes of disk. */
+    diskMb: number;
+}
+/** Terminal or running state reported by an exact process host. */
+export interface AgentExactProcessStatus {
+    pid: number;
+    running: boolean;
+    /** -1 while running; the exact process exit code after termination. */
+    exitCode: number;
+    exitSignal?: string;
+    /** Required after termination; absent only while running. */
+    termination?: AgentCandidateTermination;
+}
+/** Recoverable handle for one shell-free process. */
+export interface AgentExactProcess {
+    readonly pid: number;
+    status(options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentExactProcessStatus>;
+    wait(options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentCandidateTermination>;
+    /** Force-stop the full process tree. Idempotent after the process exits. */
+    kill(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Each iteration replays buffered UTF-8 stdout, then continues until exit. */
+    stdout(options?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<string>;
+    /** Each iteration replays buffered UTF-8 stderr, then continues until exit. */
+    stderr(options?: {
+        signal?: AbortSignal;
+    }): AsyncIterable<string>;
+}
+/** Shell-free launch whose environment replaces, rather than extends, ambient variables. */
+export interface AgentExactProcessLaunch {
+    /** Absolute path unless {@link env} supplies an explicit `PATH`. */
+    executable: string;
+    args: readonly string[];
+    cwd: string;
+    env: Readonly<Record<string, string>>;
+    stdin?: string;
+    /** Positive integer milliseconds, or zero to disable the process timeout. */
+    timeoutMs: number;
+}
+export interface AgentExactProcessManager {
+    list(options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentExactProcessStatus[]>;
+    get(pid: number, options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentExactProcess | null>;
+    /**
+     * The abort signal is checked before and after spawn dispatch.
+     * If abort is observed after a process starts, the provider kills its tree
+     * before rejecting the spawn operation.
+     */
+    spawn(input: AgentExactProcessLaunch, options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentExactProcess>;
+}
+/**
+ * Fresh environment with no provider-managed user workload.
+ *
+ * Authenticated provider control services may exist, but no customer workload
+ * ingress or provider-managed user process may exist. The launched process
+ * sees only its supplied environment variables, with no ambient or injected
+ * secrets.
+ */
+export interface AgentExactProcessEnvironment {
+    readonly id: string;
+    readonly provider: string;
+    readonly metadata?: Record<string, unknown>;
+    readonly process: AgentExactProcessManager;
+    /**
+     * Write exact bytes to an absolute path with a POSIX mode from 0 through
+     * 07777.
+     *
+     * The abort signal is checked before and after the write.
+     * Once dispatched the write is not cancellable, so an abort may reject after
+     * the bytes have landed.
+     */
+    writeFile(path: string, bytes: Uint8Array, options: {
+        mode: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Read exact bytes, or fail before content is loaded when the file exceeds
+     * maxBytes. A file that grows after the size check is still rejected, but
+     * only after its content was transferred. Reads have no side effect, so the
+     * abort signal may reject at any point.
+     */
+    readFile(path: string, options: {
+        maxBytes: number;
+        signal?: AbortSignal;
+    }): Promise<Uint8Array>;
+    destroy(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+export interface AgentExactProcessEnvironmentQuery {
+    /** Every supplied key/value must match persisted environment metadata exactly. */
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+    /** Abort a paginated lookup before the next remote page or conversion. */
+    signal?: AbortSignal;
+}
+/** Input for a fresh environment with no provider-managed agent process. */
+export interface CreateAgentExactProcessEnvironmentInput {
+    /** Provider-specific immutable image reference. */
+    image: string;
+    egress: AgentExactProcessEgressPolicy;
+    /** Positive integer milliseconds. */
+    maxLifetimeMs: number;
+    /** Positive integer milliseconds when supplied. */
+    provisionTimeoutMs?: number;
+    /** Required limits; exact execution never inherits provider defaults. */
+    resources: AgentExactProcessResources;
+    metadata: Record<string, unknown>;
+    idempotencyKey: string;
+    signal?: AbortSignal;
+    /** Provider-native fields may narrow, but never weaken, the isolation contract. */
+    providerOptions?: Record<string, unknown>;
+}
+/** Optional all-or-nothing exact process capability of an environment provider. */
+export interface AgentExactProcessProvider {
+    /**
+     * Repeating the same idempotency key and input returns the same environment.
+     * Reusing the key with any different create input must fail.
+     * Unsupported egress modes must fail instead of weakening the policy.
+     */
+    create(input: CreateAgentExactProcessEnvironmentInput): Promise<AgentExactProcessEnvironment>;
+    /** Ordinary environments must return null. */
+    get(id: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentExactProcessEnvironment | null>;
+    /** Return every matching exact environment; providers own any native pagination. */
+    list(query?: AgentExactProcessEnvironmentQuery, options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentExactProcessEnvironment[]>;
+}

package/dist/environment-exact-process.js

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