@tangle-network/agent-interface 0.32.0 → 0.34.0

package/dist/agent-profile.d.ts

@@ -3,8 +3,8 @@
  *
  * These model portable agent intent at the application boundary. Individual
  * backends translate this shape into their own native profile/configuration
- * formats internally. This is the canonical home; `@tangle-network/sandbox`
- * re-exports these symbols for backward compatibility.
+ * formats internally. This package is the canonical public home for these
+ * symbols.
  */
 import type { HarnessType } from "./harness.js";
 /**

package/dist/agent-profile.js

@@ -3,8 +3,8 @@
  *
  * These model portable agent intent at the application boundary. Individual
  * backends translate this shape into their own native profile/configuration
- * formats internally. This is the canonical home; `@tangle-network/sandbox`
- * re-exports these symbols for backward compatibility.
+ * formats internally. This package is the canonical public home for these
+ * symbols.
  */
 /**
  * Helper for creating typed inline resource refs.

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/harness-capabilities.d.ts

@@ -1,5 +1,5 @@
 import type { ReasoningEffort } from "./agent-profile.js";
-import { type HarnessType } from "./harness.js";
+import type { HarnessType } from "./harness.js";
 /**
  * The unified harness capability layer — the single source of truth for:
  *   1. harness ↔ model compatibility (which models a harness can run), and

package/dist/harness-capabilities.js

@@ -1,4 +1,3 @@
-import { canonicalizeHarness } from "./harness.js";
 /**
  * The unified harness capability layer — the single source of truth for:
  *   1. harness ↔ model compatibility (which models a harness can run), and
@@ -28,8 +27,7 @@ export const reasoningLadder = [
 // ── Harness ↔ model compatibility ────────────────────────────────────────────
 /**
  * Provider prefixes a harness is vendor-locked to (canonical-id prefix, e.g. `anthropic`, `openai`).
- * A harness with no entry is router-backed: it runs any model. Keyed by the BASE runner — aliases
- * (`claude`/`claudish`/`kimi`) resolve through `canonicalizeHarness` first.
+ * A harness with no entry is router-backed: it runs any model.
  *
  * `nanoclaw` is deliberately absent despite the "claw" name: its runner routes every provider through
  * the Tangle router (canonical model id straight to the gateway), so it is router-backed like
@@ -47,7 +45,7 @@ export function modelProvider(modelId) {
 }
 /** The providers a harness is locked to, or `null` when it is router-backed (any model). */
 export function harnessProviders(harness) {
-    return harnessProviderLock[canonicalizeHarness(harness)] ?? null;
+    return harnessProviderLock[harness] ?? null;
 }
 /**
  * Whether a harness can run a model. Router-backed harnesses (no provider lock) accept anything;
@@ -76,7 +74,7 @@ export function preferredHarnessForModel(modelId) {
 /**
  * Per-harness ranking patterns for {@link snapModelToHarness}, best first; within one pattern the
  * highest version wins (numeric-aware). Only vendor-locked harnesses need an entry — a router-backed
- * harness never snaps (it runs the model as-is). Keyed by the BASE runner (aliases canonicalized).
+ * harness never snaps (it runs the model as-is).
  */
 const harnessPreferredModelPatterns = {
     "claude-code": [
@@ -101,7 +99,7 @@ const numericDesc = new Intl.Collator(undefined, {
 export function snapModelToHarness(harness, modelId, candidateIds) {
     if (harnessSupportsModel(harness, modelId))
         return modelId;
-    const patterns = harnessPreferredModelPatterns[canonicalizeHarness(harness)] ?? [];
+    const patterns = harnessPreferredModelPatterns[harness] ?? [];
     for (const pattern of patterns) {
         const matches = candidateIds
             .filter((id) => pattern.test(id))
@@ -164,11 +162,10 @@ const harnessReasoningCeiling = {
 /** The reasoning efforts a harness can express, independent of model — its explicit override set, or
  *  `none` up to its ceiling (default `ultracode` for router/model-driven harnesses). */
 export function harnessReasoningEfforts(harness) {
-    const canonical = canonicalizeHarness(harness);
-    const override = harnessReasoningEffortsOverride[canonical];
+    const override = harnessReasoningEffortsOverride[harness];
     if (override)
         return override;
-    const ceiling = harnessReasoningCeiling[canonical] ?? "ultracode";
+    const ceiling = harnessReasoningCeiling[harness] ?? "ultracode";
     return reasoningLadder.slice(0, reasoningLadder.indexOf(ceiling) + 1);
 }
 /**
@@ -191,7 +188,7 @@ export function reasoningEffortsFor(harness, model) {
 /**
  * Harnesses whose runner DROPS a per-turn selector — grounded in the cli-bridge adapter audit, NOT a
  * guess. Most harnesses honor both selectors, so only the exceptions are listed; a harness absent from
- * a set honors that selector. Keyed by the BASE runner (aliases canonicalized).
+ * a set honors that selector.
  *
  *   - model dropped:  `amp` (own agent picks the model), `openclaw` (dispatcher routes by its own
  *     config), `nanoclaw` (socket-bridge runner is config/env-driven).
@@ -215,11 +212,11 @@ const harnessIgnoresEffort = new Set([
 ]);
 /** Whether the harness's runner honors a per-turn MODEL override (vs. picking the model itself). */
 export function harnessHonorsModel(harness) {
-    return !harnessIgnoresModel.has(canonicalizeHarness(harness));
+    return !harnessIgnoresModel.has(harness);
 }
 /** Whether the harness's runner honors a reasoning-EFFORT override (vs. dropping it). */
 export function harnessHonorsEffort(harness) {
-    return !harnessIgnoresEffort.has(canonicalizeHarness(harness));
+    return !harnessIgnoresEffort.has(harness);
 }
 /** Whether the harness honors BOTH chat selectors — i.e. the model and effort pickers are live. */
 export function harnessHonorsSelectors(harness) {

package/dist/harness.d.ts

@@ -14,20 +14,15 @@ import { z } from "zod";
  * a one-shot) with no full coding-agent harness. The rest are full agentic harnesses run in a
  * sandbox or locally via the CLI bridge.
  *
- * Some values are input aliases that collapse to a base runner (`claude`/`claudish` → `claude-code`,
- * `kimi` → `kimi-code`); normalize with {@link canonicalizeHarness} before keying per-runner config.
  */
-export type HarnessType = "claude-code" | "claude" | "claudish" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "kimi" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
+export type HarnessType = "claude-code" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
 /** Runtime validator for {@link HarnessType}. Kept in lockstep with the type by the drift guard below. */
 export declare const harnessTypeSchema: z.ZodEnum<{
     "claude-code": "claude-code";
-    claude: "claude";
-    claudish: "claudish";
     nanoclaw: "nanoclaw";
     codex: "codex";
     opencode: "opencode";
     "kimi-code": "kimi-code";
-    kimi: "kimi";
     pi: "pi";
     gemini: "gemini";
     hermes: "hermes";
@@ -37,7 +32,3 @@ export declare const harnessTypeSchema: z.ZodEnum<{
     acp: "acp";
     "cli-base": "cli-base";
 }>;
-/** Input alias → canonical base runner. Aliases accept legacy/shorthand harness names. */
-export declare const harnessAliases: Partial<Record<HarnessType, HarnessType>>;
-/** Collapse an alias to its base runner (idempotent on canonical values). */
-export declare function canonicalizeHarness(harness: HarnessType): HarnessType;

package/dist/harness.js

@@ -2,13 +2,10 @@ import { z } from "zod";
 /** Runtime validator for {@link HarnessType}. Kept in lockstep with the type by the drift guard below. */
 export const harnessTypeSchema = z.enum([
     "claude-code",
-    "claude",
-    "claudish",
     "nanoclaw",
     "codex",
     "opencode",
     "kimi-code",
-    "kimi",
     "pi",
     "gemini",
     "hermes",
@@ -18,15 +15,5 @@ export const harnessTypeSchema = z.enum([
     "acp",
     "cli-base",
 ]);
-/** Input alias → canonical base runner. Aliases accept legacy/shorthand harness names. */
-export const harnessAliases = {
-    claude: "claude-code",
-    claudish: "claude-code",
-    kimi: "kimi-code",
-};
-/** Collapse an alias to its base runner (idempotent on canonical values). */
-export function canonicalizeHarness(harness) {
-    return harnessAliases[harness] ?? harness;
-}
 const _harnessSchemaMatchesType = true;
 void _harnessSchemaMatchesType;

package/dist/index.d.ts

@@ -157,7 +157,7 @@ export declare function normalizeInputParts(input: {
 export declare function renderInputPartsAsText(parts: InputPart[]): string;
 /**
  * The primary event for all part updates from OpenCode.
- * This is the canonical event - use this instead of legacy events.
+ * This is the canonical event for all part updates.
  */
 export type MessagePartUpdatedEvent = {
     type: "message.part.updated";
@@ -614,7 +614,12 @@ export * from "./interaction.js";
 export * from "./agent-candidate.js";
 export * from "./agent-candidate-schema.js";
 export * from "./agent-candidate-promotion-schema.js";
+export { agentCandidateEvaluationPolicySchema } from "./agent-improvement-measurement-schema.js";
+export * from "./agent-improvement-source.js";
+export * from "./agent-profile-improvement.js";
+export * from "./agent-profile-improvement-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

@@ -127,7 +127,12 @@ export * from "./interaction.js";
 export * from "./agent-candidate.js";
 export * from "./agent-candidate-schema.js";
 export * from "./agent-candidate-promotion-schema.js";
+export { agentCandidateEvaluationPolicySchema } from "./agent-improvement-measurement-schema.js";
+export * from "./agent-improvement-source.js";
+export * from "./agent-profile-improvement.js";
+export * from "./agent-profile-improvement-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/interaction.d.ts

@@ -256,23 +256,6 @@ export type PermissionGrant = z.infer<typeof PermissionGrantSchema>;
 export declare function permissionAnswerSpec(opts?: {
     allowFeedback?: boolean;
 }): InteractionAnswerSpec;
-/** Shape of one legacy question (kept for the back-compat shim). */
-export type LegacyQuestion = {
-    question: string;
-    options?: Array<{
-        label: string;
-        description?: string;
-    }>;
-    multiSelect?: boolean;
-    /** When true the select field accepts write-in answers beyond `options`. */
-    allowCustom?: boolean;
-};
-/**
- * Build an answer spec from the legacy `question` event shape. Each question
- * becomes one select field (free text when it declares no options), so the old
- * question/answer path is expressible as a `question` interaction.
- */
-export declare function questionAnswerSpec(questions: LegacyQuestion[]): InteractionAnswerSpec;
 export type InteractionValidation = {
     ok: true;
 } | {

package/dist/interaction.js

@@ -176,29 +176,6 @@ export function permissionAnswerSpec(opts) {
     }
     return { fields };
 }
-/**
- * Build an answer spec from the legacy `question` event shape. Each question
- * becomes one select field (free text when it declares no options), so the old
- * question/answer path is expressible as a `question` interaction.
- */
-export function questionAnswerSpec(questions) {
-    const fields = questions.map((q, i) => {
-        const name = `q${i}`;
-        if (q.options && q.options.length > 0) {
-            return {
-                type: "select",
-                name,
-                label: q.question,
-                required: true,
-                multi: q.multiSelect === true,
-                ...(q.allowCustom === true ? { allowCustom: true } : {}),
-                options: q.options.map((o) => ({ value: o.label, label: o.label, description: o.description })),
-            };
-        }
-        return { type: "text", name, label: q.question, required: true };
-    });
-    return { fields };
-}
 /**
  * Validate an accepted answer against its spec. Used by the broker before a
  * response reaches the adapter, so malformed answers are rejected centrally.

package/dist/number-validation.d.ts

@@ -0,0 +1 @@
+export declare function numbersApproximatelyEqual(left: number, right: number): boolean;

package/dist/number-validation.js

@@ -0,0 +1,4 @@
+export function numbersApproximatelyEqual(left, right) {
+    const tolerance = Number.EPSILON * Math.max(1, Math.abs(left), Math.abs(right)) * 16;
+    return Math.abs(left - right) <= tolerance;
+}

package/dist/profile-schema.d.ts

@@ -268,13 +268,10 @@ export declare const agentProfileSchema: z.ZodObject<{
     }, z.core.$strict>>;
     harness: z.ZodOptional<z.ZodEnum<{
         "claude-code": "claude-code";
-        claude: "claude";
-        claudish: "claudish";
         nanoclaw: "nanoclaw";
         codex: "codex";
         opencode: "opencode";
         "kimi-code": "kimi-code";
-        kimi: "kimi";
         pi: "pi";
         gemini: "gemini";
         hermes: "hermes";

package/package.json

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