@tangle-network/agent-interface 0.31.0 → 0.33.0

package/README.md

@@ -62,6 +62,13 @@ const provider: AgentEnvironmentProvider = {
 };
 ```
 
+## Exact process environments
+
+Providers may expose the optional `exactProcess` capability for isolated, reproducible process execution.
+It is separate from agent-backed `create()` because it guarantees a fresh environment, immutable image identity, explicit resources, bounded exact-byte file reads, shell-free argv, replacement process environment, recoverable output and terminal reason, bounded network access, and collision-safe idempotent recovery without starting a provider-managed agent.
+Higher-level runtimes can use this primitive for measured candidates without making candidate lifecycle part of the provider contract.
+Providers must omit the capability unless every property is enforced on their real execution path.
+
 ## Frozen improvement candidates
 
 `AgentCandidateBundle` is the portable output of an improvement run: a recursively strict profile, an explicit disabled/no-op/changed code result, a shell-free launch, optional knowledge, isolated memory, ancestry, and spend.

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

@@ -174,6 +174,16 @@ export const agentCandidateExecutionSchema = z
 })
     .strict()
     .superRefine((execution, ctx) => {
+    const requiresPath = execution.launch.kind === "container-command"
+        ? !execution.launch.executable.startsWith("/")
+        : execution.launch.interpreter !== undefined;
+    if (requiresPath && !execution.env?.PATH?.value.trim()) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["env", "PATH"],
+            message: "relative candidate executables require an explicit public PATH",
+        });
+    }
     if (execution.env?.TANGLE_CANDIDATE_TASK_PATH !== undefined) {
         ctx.addIssue({
             code: "custom",

package/dist/agent-candidate-execution-plan-schema.js

@@ -320,6 +320,13 @@ export const agentCandidateExecutionPlanMaterialSchema = z
 })
     .strict()
     .superRefine((material, ctx) => {
+    if (!material.launch.executable.startsWith("/") && !material.launch.env.PATH?.value.trim()) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["launch", "env", "PATH"],
+            message: "relative execution-plan executables require an explicit public PATH",
+        });
+    }
     const routeIds = material.model.routes.map((route) => route.kind === "mode" || route.kind === "subagent"
         ? `${route.kind}:${route.name}`
         : route.kind);

package/dist/agent-candidate.test-fixture.d.ts

@@ -71,6 +71,10 @@ export declare function candidateFixture(): {
                 kind: "public";
                 value: string;
             };
+            PATH: {
+                kind: "public";
+                value: string;
+            };
         };
         environment: {
             kind: "pinned-container";

package/dist/agent-candidate.test-fixture.js

@@ -62,6 +62,7 @@ export function candidateFixture() {
             cwd: { workspace: "candidate", path: "." },
             env: {
                 NODE_ENV: { kind: "public", value: "production" },
+                PATH: { kind: "public", value: "/usr/local/bin:/usr/bin:/bin" },
             },
             environment: {
                 kind: "pinned-container",

package/dist/certified-context.d.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+export type CertifiedContextKind = "prompt" | "skill" | "instructions";
+export type CertifiedContextDelivery = {
+    readonly kind: "inline";
+    readonly content: string;
+} | {
+    readonly kind: "file";
+    readonly path: string;
+    readonly content: string;
+};
+export interface CertifiedContextProvenance {
+    /** SHA-256 of the entry id, kind, name, and delivery. */
+    readonly contentHash: Sha256Digest;
+    /** Positive release number, or null when the source has no released version. */
+    readonly version: number | null;
+    readonly promotedAt: string;
+}
+export interface CertifiedContextEntry {
+    readonly id: string;
+    readonly kind: CertifiedContextKind;
+    readonly name: string;
+    readonly delivery: CertifiedContextDelivery;
+    readonly provenance: CertifiedContextProvenance;
+}
+/**
+ * Tenant-bound context delivered by Intelligence.
+ *
+ * This contract intentionally excludes tools, credentials, executable files,
+ * profile patches, MCP servers, and arbitrary network requests.
+ */
+export interface CertifiedContext {
+    readonly tenantId: string;
+    readonly target: string;
+    readonly state: "active" | "revoked";
+    /** Monotonic decimal revision for this tenant and target. */
+    readonly revision: string;
+    readonly generatedAt: string;
+    readonly expiresAt: string;
+    readonly entries: readonly CertifiedContextEntry[];
+    /** SHA-256 of tenantId, target, state, revision, and entries. */
+    readonly contentHash: Sha256Digest;
+}
+export declare const certifiedContextDeliverySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"inline">;
+    content: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"file">;
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const certifiedContextProvenanceSchema: z.ZodObject<{
+    contentHash: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    version: z.ZodNullable<z.ZodNumber>;
+    promotedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+/** Compute the exact digest stored in an entry's provenance. */
+export declare function certifiedContextEntryContentHash(entry: Pick<CertifiedContextEntry, "id" | "kind" | "name" | "delivery">): Sha256Digest;
+export declare const certifiedContextEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        prompt: "prompt";
+        instructions: "instructions";
+        skill: "skill";
+    }>;
+    name: z.ZodString;
+    delivery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+        content: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"file">;
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    provenance: z.ZodObject<{
+        contentHash: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        version: z.ZodNullable<z.ZodNumber>;
+        promotedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Compute the stable hash for one context revision. */
+export declare function certifiedContextContentHash(context: Pick<CertifiedContext, "tenantId" | "target" | "state" | "revision" | "entries">): Sha256Digest;
+export declare const certifiedContextSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    target: z.ZodString;
+    state: z.ZodEnum<{
+        active: "active";
+        revoked: "revoked";
+    }>;
+    revision: z.ZodString;
+    generatedAt: z.ZodISODateTime;
+    expiresAt: z.ZodISODateTime;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            prompt: "prompt";
+            instructions: "instructions";
+            skill: "skill";
+        }>;
+        name: z.ZodString;
+        delivery: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"inline">;
+            content: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"file">;
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        provenance: z.ZodObject<{
+            contentHash: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            version: z.ZodNullable<z.ZodNumber>;
+            promotedAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    contentHash: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+/** Parse, clone, and recursively freeze one untrusted context response. */
+export declare function parseCertifiedContext(value: unknown): CertifiedContext;

package/dist/certified-context.js

@@ -0,0 +1,228 @@
+import { z } from "zod";
+import { canonicalCandidateDigest, isSafeRelativePath, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+const MAX_INLINE_CONTEXT_BYTES = 65_536;
+const MAX_TOTAL_INLINE_CONTEXT_BYTES = 131_072;
+const MAX_FILE_CONTEXT_BYTES = 1_048_576;
+const MAX_CERTIFIED_CONTEXT_BYTES = 16_777_216;
+const MAX_CERTIFIED_CONTEXT_LIFETIME_MS = 900_000;
+const revisionPattern = /^(0|[1-9]\d{0,18})$/;
+const nonBlankStringSchema = z
+    .string()
+    .refine((value) => value.trim().length > 0, "value cannot be blank");
+const identifierSchema = nonBlankStringSchema.max(256);
+const relativePathSchema = nonBlankStringSchema
+    .max(1_024)
+    .refine((value) => isSafeRelativePath(value, false), "value must be a canonical relative path");
+const inlineContentSchema = z
+    .string()
+    .max(MAX_INLINE_CONTEXT_BYTES)
+    .refine((value) => new TextEncoder().encode(value).byteLength <= MAX_INLINE_CONTEXT_BYTES, `inline content exceeds ${MAX_INLINE_CONTEXT_BYTES} UTF-8 bytes`);
+const fileContentSchema = z
+    .string()
+    .max(MAX_FILE_CONTEXT_BYTES)
+    .refine((value) => new TextEncoder().encode(value).byteLength <= MAX_FILE_CONTEXT_BYTES, `file content exceeds ${MAX_FILE_CONTEXT_BYTES} UTF-8 bytes`);
+export const certifiedContextDeliverySchema = z.discriminatedUnion("kind", [
+    z.strictObject({
+        kind: z.literal("inline"),
+        content: inlineContentSchema,
+    }),
+    z.strictObject({
+        kind: z.literal("file"),
+        path: relativePathSchema,
+        content: fileContentSchema,
+    }),
+]);
+export const certifiedContextProvenanceSchema = z.strictObject({
+    contentHash: sha256DigestSchema,
+    version: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).nullable(),
+    promotedAt: z.iso.datetime(),
+});
+function jsonMaterial(value) {
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined) {
+        throw new Error("certified context material must be JSON serializable");
+    }
+    return JSON.parse(serialized);
+}
+/** Compute the exact digest stored in an entry's provenance. */
+export function certifiedContextEntryContentHash(entry) {
+    return canonicalCandidateDigest(jsonMaterial({
+        id: entry.id,
+        kind: entry.kind,
+        name: entry.name,
+        delivery: entry.delivery,
+    }));
+}
+export const certifiedContextEntrySchema = z
+    .strictObject({
+    id: identifierSchema,
+    kind: z.enum(["prompt", "skill", "instructions"]),
+    name: identifierSchema,
+    delivery: certifiedContextDeliverySchema,
+    provenance: certifiedContextProvenanceSchema,
+})
+    .superRefine((entry, context) => {
+    if (entry.kind === "skill" && entry.delivery.kind !== "file") {
+        context.addIssue({
+            code: "custom",
+            path: ["delivery", "kind"],
+            message: "skills must be delivered as files",
+        });
+    }
+    if (entry.kind !== "skill" && entry.delivery.kind !== "inline") {
+        context.addIssue({
+            code: "custom",
+            path: ["delivery", "kind"],
+            message: "prompts and instructions must be delivered inline",
+        });
+    }
+    if (entry.delivery.kind === "inline" &&
+        entry.delivery.content.trim().length === 0) {
+        context.addIssue({
+            code: "custom",
+            path: ["delivery", "content"],
+            message: "inline context cannot be blank",
+        });
+    }
+    if (entry.provenance.contentHash !== certifiedContextEntryContentHash(entry)) {
+        context.addIssue({
+            code: "custom",
+            path: ["provenance", "contentHash"],
+            message: "entry content hash does not match the delivered context",
+        });
+    }
+});
+/** Compute the stable hash for one context revision. */
+export function certifiedContextContentHash(context) {
+    return canonicalCandidateDigest(jsonMaterial(context));
+}
+export const certifiedContextSchema = z
+    .strictObject({
+    tenantId: identifierSchema,
+    target: identifierSchema,
+    state: z.enum(["active", "revoked"]),
+    revision: z
+        .string()
+        .regex(revisionPattern)
+        .refine((value) => !revisionPattern.test(value) ||
+        BigInt(value) <= 9223372036854775807n, "revision exceeds signed 64-bit range"),
+    generatedAt: z.iso.datetime(),
+    expiresAt: z.iso.datetime(),
+    entries: z.array(certifiedContextEntrySchema).max(128),
+    contentHash: sha256DigestSchema,
+})
+    .superRefine((context, refinement) => {
+    const generatedAt = Date.parse(context.generatedAt);
+    const expiresAt = Date.parse(context.expiresAt);
+    if (expiresAt <= generatedAt) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["expiresAt"],
+            message: "expiresAt must be after generatedAt",
+        });
+    }
+    else if (expiresAt - generatedAt >
+        MAX_CERTIFIED_CONTEXT_LIFETIME_MS) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["expiresAt"],
+            message: "certified context cannot live longer than 15 minutes",
+        });
+    }
+    const serialized = JSON.stringify(context);
+    if (new TextEncoder().encode(serialized).byteLength >
+        MAX_CERTIFIED_CONTEXT_BYTES) {
+        refinement.addIssue({
+            code: "too_big",
+            maximum: MAX_CERTIFIED_CONTEXT_BYTES,
+            origin: "string",
+            inclusive: true,
+            message: `serialized context exceeds ${MAX_CERTIFIED_CONTEXT_BYTES} UTF-8 bytes`,
+        });
+    }
+    const ids = new Set();
+    const filePaths = new Set();
+    let inlineBytes = 0;
+    for (const [index, entry] of context.entries.entries()) {
+        if (ids.has(entry.id)) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["entries", index, "id"],
+                message: `duplicate context id: ${entry.id}`,
+            });
+        }
+        ids.add(entry.id);
+        if (entry.delivery.kind === "file") {
+            if (filePaths.has(entry.delivery.path)) {
+                refinement.addIssue({
+                    code: "custom",
+                    path: ["entries", index, "delivery", "path"],
+                    message: `duplicate file path: ${entry.delivery.path}`,
+                });
+            }
+            filePaths.add(entry.delivery.path);
+        }
+        else {
+            inlineBytes += new TextEncoder().encode(entry.delivery.content).byteLength;
+        }
+        if (Date.parse(entry.provenance.promotedAt) > generatedAt) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["entries", index, "provenance", "promotedAt"],
+                message: "context cannot be promoted after bundle generation",
+            });
+        }
+    }
+    if (inlineBytes > MAX_TOTAL_INLINE_CONTEXT_BYTES) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["entries"],
+            message: `inline context exceeds ${MAX_TOTAL_INLINE_CONTEXT_BYTES} UTF-8 bytes`,
+        });
+    }
+    if ((context.state === "active" && context.entries.length === 0) ||
+        (context.state === "revoked" && context.entries.length !== 0)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["entries"],
+            message: "active context requires entries and revoked context requires none",
+        });
+    }
+    const material = {
+        tenantId: context.tenantId,
+        target: context.target,
+        state: context.state,
+        revision: context.revision,
+        entries: context.entries,
+    };
+    if (context.contentHash !== certifiedContextContentHash(material)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["contentHash"],
+            message: "context content hash does not match the delivered context",
+        });
+    }
+});
+function deepFreeze(value) {
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const child of Object.values(value)) {
+            deepFreeze(child);
+        }
+        Object.freeze(value);
+    }
+    return value;
+}
+const _certifiedContextDeliverySchemaMatches = true;
+const _certifiedContextProvenanceSchemaMatches = true;
+const _certifiedContextEntrySchemaMatches = true;
+const _certifiedContextSchemaMatches = true;
+void [
+    _certifiedContextDeliverySchemaMatches,
+    _certifiedContextProvenanceSchemaMatches,
+    _certifiedContextEntrySchemaMatches,
+    _certifiedContextSchemaMatches,
+];
+/** Parse, clone, and recursively freeze one untrusted context response. */
+export function parseCertifiedContext(value) {
+    return deepFreeze(certifiedContextSchema.parse(value));
+}

package/dist/environment-provider.d.ts

@@ -1,4 +1,5 @@
 import type { AgentProfile, AgentProfileCapabilities, AgentProfileValidationResult } from "./agent-profile.js";
+import type { AgentCandidateTermination } from "./agent-candidate.js";
 import type { InputPart, StreamEvent, TokenUsage } from "./index.js";
 /** Portable profile reference: inline profile or provider catalog id. */
 export type AgentProfileRef = AgentProfile | string;
@@ -48,6 +49,128 @@ export interface ExecResult {
     stdout: string;
     stderr: string;
 }
+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(): Promise<AgentExactProcessStatus>;
+    wait(): Promise<AgentCandidateTermination>;
+    /** Force-stop the full process tree. Idempotent after the process exits. */
+    kill(): Promise<void>;
+    /** Each iteration replays buffered UTF-8 stdout, then continues until exit. */
+    stdout(): AsyncIterable<string>;
+    /** Each iteration replays buffered UTF-8 stderr, then continues until exit. */
+    stderr(): 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(): Promise<AgentExactProcessStatus[]>;
+    get(pid: number): Promise<AgentExactProcess | null>;
+    /** Providers must honor the abort signal when supplied. */
+    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. Providers must honor the abort signal when supplied. */
+    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. */
+    readFile(path: string, options: {
+        maxBytes: number;
+        signal?: AbortSignal;
+    }): Promise<Uint8Array>;
+    destroy(): Promise<void>;
+}
+export interface AgentExactProcessEnvironmentQuery {
+    /** Every supplied key/value must match persisted environment metadata exactly. */
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}
+/** 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): Promise<AgentExactProcessEnvironment | null>;
+    /** Return every matching exact environment; providers own any native pagination. */
+    list(query?: AgentExactProcessEnvironmentQuery): Promise<AgentExactProcessEnvironment[]>;
+}
 export interface CheckpointRequest {
     name?: string;
     metadata?: Record<string, unknown>;
@@ -165,6 +288,10 @@ export interface AgentEnvironmentCapabilities {
     placement: boolean;
     usage: boolean;
     confidential: boolean;
+    /** Present only when {@link AgentEnvironmentProvider.exactProcess} is implemented. */
+    exactProcess?: {
+        egress: readonly AgentExactProcessEgressMode[];
+    };
 }
 export interface CreateAgentEnvironmentInput {
     profile: AgentProfileRef;
@@ -182,6 +309,7 @@ export interface CreateAgentEnvironmentInput {
 }
 export interface AgentEnvironmentProvider {
     readonly name: string;
+    readonly exactProcess?: AgentExactProcessProvider;
     capabilities(): AgentEnvironmentCapabilities | Promise<AgentEnvironmentCapabilities>;
     validateProfile?(profile: AgentProfileRef): AgentProfileValidationResult | Promise<AgentProfileValidationResult>;
     create(input: CreateAgentEnvironmentInput): Promise<AgentEnvironment>;

package/dist/index.d.ts

@@ -615,6 +615,7 @@ export * from "./agent-candidate.js";
 export * from "./agent-candidate-schema.js";
 export * from "./agent-candidate-promotion-schema.js";
 export * from "./agent-profile.js";
+export * from "./certified-context.js";
 export * from "./profile-diff.js";
 export * from "./harness.js";
 export * from "./harness-capabilities.js";

package/dist/index.js

@@ -128,6 +128,7 @@ export * from "./agent-candidate.js";
 export * from "./agent-candidate-schema.js";
 export * from "./agent-candidate-promotion-schema.js";
 export * from "./agent-profile.js";
+export * from "./certified-context.js";
 export * from "./profile-diff.js";
 export * from "./harness.js";
 export * from "./harness-capabilities.js";

package/package.json

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