@themoltnet/pi-extension 0.22.2 → 0.22.4

package/dist/index.d.ts

@@ -8,24 +8,11 @@ import { LoadSkillsResult } from '@earendil-works/pi-coding-agent';
 import { Model } from '@earendil-works/pi-ai';
 import { ReadOperations } from '@earendil-works/pi-coding-agent';
 import { Skill } from '@earendil-works/pi-coding-agent';
-import { Static } from '@sinclair/typebox';
-import { TArray } from '@sinclair/typebox';
-import { TBoolean } from '@sinclair/typebox';
-import { TInteger } from '@sinclair/typebox';
-import { TLiteral } from '@sinclair/typebox';
-import { TNull } from '@sinclair/typebox';
-import { TNumber } from '@sinclair/typebox';
-import { TObject } from '@sinclair/typebox';
+import { Static } from 'typebox';
+import { TObject } from 'typebox';
 import { ToolDefinition } from '@earendil-works/pi-coding-agent';
-import { TOptional } from '@sinclair/typebox';
-import { TRecord } from '@sinclair/typebox';
-import { TRecursive } from '@sinclair/typebox';
-import { TRefUnsafe } from '@sinclair/typebox';
-import { TSchema } from '@sinclair/typebox';
-import { TString } from '@sinclair/typebox';
-import { TThis } from '@sinclair/typebox';
-import { TUnion } from '@sinclair/typebox';
-import { TUnknown } from '@sinclair/typebox';
+import { TSchema } from 'typebox';
+import { Type } from 'typebox';
 import { VM } from '@earendil-works/gondolin';
 import { WriteOperations } from '@earendil-works/pi-coding-agent';
 
@@ -74,6 +61,23 @@ declare interface BuildAgentSessionArgs {
     };
 }
 
+declare type ClaimCondition = {
+    op: 'all';
+    conditions: ClaimCondition[];
+} | {
+    op: 'any';
+    conditions: ClaimCondition[];
+} | {
+    op: 'task_status';
+    taskId: string;
+    statuses: TaskStatus[];
+} | {
+    op: 'task_accepted';
+    taskId: string;
+};
+
+declare const ClaimCondition: Type.TUnsafe<ClaimCondition>;
+
 declare interface ClaimedTask {
     /** The claimed task payload itself. */
     task: Task;
@@ -105,10 +109,10 @@ declare interface ClaimedTask {
  *               short example skills, not the kind of skill the eval
  *               substrate is dogfooded on (#943, #823).
  */
-declare const ContextRef: TObject<    {
-    slug: TString;
-    binding: TUnion<[TLiteral<"skill">, TLiteral<"context_inline">, TLiteral<"prompt_prefix">, TLiteral<"user_inline">]>;
-    content: TString;
+declare const ContextRef: Type.TObject<{
+    slug: Type.TString;
+    binding: Type.TUnion<[Type.TLiteral<"skill">, Type.TLiteral<"context_inline">, Type.TLiteral<"prompt_prefix">, Type.TLiteral<"user_inline">]>;
+    content: Type.TString;
 }>;
 
 declare type ContextRef = Static<typeof ContextRef>;
@@ -671,8 +675,8 @@ export declare interface SubagentToolHandle {
  *                      Resolved at call time; unknown names error.
  */
 export declare const SubagentToolParameters: TObject<{
-    task: TString;
-    output_schema: TString;
+    task: Type.TString;
+    output_schema: Type.TString;
 }>;
 
 export declare type SubagentToolParameters = Static<typeof SubagentToolParameters>;
@@ -684,83 +688,70 @@ export declare type SubagentToolParameters = Static<typeof SubagentToolParameter
  * `taskType`. Type-specific payload lives inside `input` (validated
  * against the schema registered for `taskType`).
  */
-declare const Task: TObject<    {
-    id: TString;
-    taskType: TString;
-    title: TUnion<[TString, TNull]>;
-    tags: TArray<TString>;
-    teamId: TString;
-    diaryId: TUnion<[TString, TNull]>;
-    outputKind: TUnion<[TLiteral<"artifact">, TLiteral<"judgment">]>;
-    input: TRecord<TString, TUnknown>;
-    inputSchemaCid: TString;
-    inputCid: TString;
-    references: TArray<TObject<    {
-        taskId: TUnion<[TString, TNull]>;
-        outputCid: TString;
-        role: TUnion<[TLiteral<"judged_work">, TLiteral<"reviewed_diff">, TLiteral<"target_source">, TLiteral<"context">]>;
-        external: TOptional<TObject<    {
-            kind: TUnion<[TLiteral<"github_pr">, TLiteral<"github_issue">, TLiteral<"http_url">]>;
-            pr: TOptional<TNumber>;
-            issue: TOptional<TNumber>;
-            url: TOptional<TString>;
-            commit_sha: TOptional<TString>;
-            snapshot_cid: TOptional<TString>;
+declare const Task: Type.TObject<{
+    id: Type.TString;
+    taskType: Type.TString;
+    title: Type.TUnion<[Type.TString, Type.TNull]>;
+    tags: Type.TArray<Type.TString>;
+    teamId: Type.TString;
+    diaryId: Type.TUnion<[Type.TString, Type.TNull]>;
+    outputKind: Type.TUnion<[Type.TLiteral<"artifact">, Type.TLiteral<"judgment">]>;
+    input: Type.TRecord<"^.*$", Type.TUnknown>;
+    inputSchemaCid: Type.TString;
+    inputCid: Type.TString;
+    references: Type.TArray<Type.TObject<{
+        taskId: Type.TUnion<[Type.TString, Type.TNull]>;
+        outputCid: Type.TString;
+        role: Type.TUnion<[Type.TLiteral<"judged_work">, Type.TLiteral<"reviewed_diff">, Type.TLiteral<"target_source">, Type.TLiteral<"context">]>;
+        external: Type.TOptional<Type.TObject<{
+            kind: Type.TUnion<[Type.TLiteral<"github_pr">, Type.TLiteral<"github_issue">, Type.TLiteral<"http_url">]>;
+            pr: Type.TOptional<Type.TNumber>;
+            issue: Type.TOptional<Type.TNumber>;
+            url: Type.TOptional<Type.TString>;
+            commit_sha: Type.TOptional<Type.TString>;
+            snapshot_cid: Type.TOptional<Type.TString>;
         }>>;
     }>>;
-    correlationId: TUnion<[TString, TNull]>;
-    proposedByAgentId: TUnion<[TString, TNull]>;
-    proposedByHumanId: TUnion<[TString, TNull]>;
-    acceptedAttemptN: TUnion<[TNumber, TNull]>;
-    claimCondition: TUnion<[TRecursive<TUnion<[TObject<    {
-        op: TLiteral<"all">;
-        conditions: TArray<TThis>;
-    }>, TObject<    {
-        op: TLiteral<"any">;
-        conditions: TArray<TThis>;
-    }>, TObject<    {
-        op: TLiteral<"task_status">;
-        taskId: TString;
-        statuses: TArray<TRefUnsafe<TUnion<[TLiteral<"waiting">, TLiteral<"queued">, TLiteral<"dispatched">, TLiteral<"running">, TLiteral<"completed">, TLiteral<"failed">, TLiteral<"cancelled">, TLiteral<"expired">]>>>;
-    }>, TObject<    {
-        op: TLiteral<"task_accepted">;
-        taskId: TString;
-    }>]>>, TNull]>;
-    requiredExecutorTrustLevel: TUnion<[TLiteral<"selfDeclared">, TLiteral<"agentSigned">, TLiteral<"releaseVerifiedTool">, TLiteral<"sandboxAttested">]>;
-    allowedExecutors: TArray<TObject<    {
-        provider: TString;
-        model: TString;
+    correlationId: Type.TUnion<[Type.TString, Type.TNull]>;
+    proposedByAgentId: Type.TUnion<[Type.TString, Type.TNull]>;
+    proposedByHumanId: Type.TUnion<[Type.TString, Type.TNull]>;
+    acceptedAttemptN: Type.TUnion<[Type.TNumber, Type.TNull]>;
+    claimCondition: Type.TUnion<[Type.TUnsafe<ClaimCondition>, Type.TNull]>;
+    requiredExecutorTrustLevel: Type.TUnion<[Type.TLiteral<"selfDeclared">, Type.TLiteral<"agentSigned">, Type.TLiteral<"releaseVerifiedTool">, Type.TLiteral<"sandboxAttested">]>;
+    allowedExecutors: Type.TArray<Type.TObject<{
+        provider: Type.TString;
+        model: Type.TString;
     }>>;
-    status: TUnion<[TLiteral<"waiting">, TLiteral<"queued">, TLiteral<"dispatched">, TLiteral<"running">, TLiteral<"completed">, TLiteral<"failed">, TLiteral<"cancelled">, TLiteral<"expired">]>;
-    queuedAt: TString;
-    completedAt: TUnion<[TString, TNull]>;
-    expiresAt: TUnion<[TString, TNull]>;
-    cancelledByAgentId: TUnion<[TString, TNull]>;
-    cancelledByHumanId: TUnion<[TString, TNull]>;
-    cancelReason: TUnion<[TString, TNull]>;
-    maxAttempts: TNumber;
-    dispatchTimeoutSec: TUnion<[TInteger, TNull]>;
-    runningTimeoutSec: TUnion<[TInteger, TNull]>;
+    status: Type.TUnion<[Type.TLiteral<"waiting">, Type.TLiteral<"queued">, Type.TLiteral<"dispatched">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"expired">]>;
+    queuedAt: Type.TString;
+    completedAt: Type.TUnion<[Type.TString, Type.TNull]>;
+    expiresAt: Type.TUnion<[Type.TString, Type.TNull]>;
+    cancelledByAgentId: Type.TUnion<[Type.TString, Type.TNull]>;
+    cancelledByHumanId: Type.TUnion<[Type.TString, Type.TNull]>;
+    cancelReason: Type.TUnion<[Type.TString, Type.TNull]>;
+    maxAttempts: Type.TNumber;
+    dispatchTimeoutSec: Type.TUnion<[Type.TInteger, Type.TNull]>;
+    runningTimeoutSec: Type.TUnion<[Type.TInteger, Type.TNull]>;
 }>;
 
 declare type Task = Static<typeof Task>;
 
 /** Reusable input fragment for any task type. Soft cap at 5 items. */
-declare const TaskContext: TArray<TObject<    {
-    slug: TString;
-    binding: TUnion<[TLiteral<"skill">, TLiteral<"context_inline">, TLiteral<"prompt_prefix">, TLiteral<"user_inline">]>;
-    content: TString;
+declare const TaskContext: Type.TArray<Type.TObject<{
+    slug: Type.TString;
+    binding: Type.TUnion<[Type.TLiteral<"skill">, Type.TLiteral<"context_inline">, Type.TLiteral<"prompt_prefix">, Type.TLiteral<"user_inline">]>;
+    content: Type.TString;
 }>>;
 
 declare type TaskContext = Static<typeof TaskContext>;
 
-declare const TaskMessage: TObject<    {
-    taskId: TString;
-    attemptN: TNumber;
-    seq: TNumber;
-    timestamp: TString;
-    kind: TUnion<[TLiteral<"text_delta">, TLiteral<"tool_call_start">, TLiteral<"tool_call_end">, TLiteral<"turn_end">, TLiteral<"error">, TLiteral<"info">]>;
-    payload: TRecord<TString, TUnknown>;
+declare const TaskMessage: Type.TObject<{
+    taskId: Type.TString;
+    attemptN: Type.TNumber;
+    seq: Type.TNumber;
+    timestamp: Type.TString;
+    kind: Type.TUnion<[Type.TLiteral<"text_delta">, Type.TLiteral<"tool_call_start">, Type.TLiteral<"tool_call_end">, Type.TLiteral<"turn_end">, Type.TLiteral<"error">, Type.TLiteral<"info">]>;
+    payload: Type.TRecord<"^.*$", Type.TUnknown>;
 }>;
 
 declare type TaskMessage = Static<typeof TaskMessage>;
@@ -770,29 +761,29 @@ declare type TaskMessage = Static<typeof TaskMessage>;
  * the compact shape the runtime surfaces back to whoever drove it
  * (stdout reporter, API reporter in PR 7, etc.).
  */
-declare const TaskOutput: TObject<    {
-    taskId: TString;
-    attemptN: TNumber;
-    status: TUnion<[TLiteral<"completed">, TLiteral<"failed">, TLiteral<"cancelled">]>;
-    output: TUnion<[TRecord<TString, TUnknown>, TNull]>;
-    outputCid: TUnion<[TString, TNull]>;
-    usage: TObject<    {
-        inputTokens: TInteger;
-        outputTokens: TInteger;
-        cacheReadTokens: TOptional<TInteger>;
-        cacheWriteTokens: TOptional<TInteger>;
-        toolCalls: TOptional<TInteger>;
-        model: TOptional<TString>;
-        provider: TOptional<TString>;
+declare const TaskOutput: Type.TObject<{
+    taskId: Type.TString;
+    attemptN: Type.TNumber;
+    status: Type.TUnion<[Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">]>;
+    output: Type.TUnion<[Type.TRecord<"^.*$", Type.TUnknown>, Type.TNull]>;
+    outputCid: Type.TUnion<[Type.TString, Type.TNull]>;
+    usage: Type.TObject<{
+        inputTokens: Type.TInteger;
+        outputTokens: Type.TInteger;
+        cacheReadTokens: Type.TOptional<Type.TInteger>;
+        cacheWriteTokens: Type.TOptional<Type.TInteger>;
+        toolCalls: Type.TOptional<Type.TInteger>;
+        model: Type.TOptional<Type.TString>;
+        provider: Type.TOptional<Type.TString>;
     }>;
-    durationMs: TNumber;
-    error: TOptional<TObject<    {
-        code: TString;
-        message: TString;
-        stack: TOptional<TString>;
-        retryable: TOptional<TBoolean>;
+    durationMs: Type.TNumber;
+    error: Type.TOptional<Type.TObject<{
+        code: Type.TString;
+        message: Type.TString;
+        stack: Type.TOptional<Type.TString>;
+        retryable: Type.TOptional<Type.TBoolean>;
     }>>;
-    contentSignature: TOptional<TString>;
+    contentSignature: Type.TOptional<Type.TString>;
 }>;
 
 declare type TaskOutput = Static<typeof TaskOutput>;
@@ -855,19 +846,23 @@ declare interface TaskReporter {
     readonly cancelReason: string | null;
 }
 
+declare const TaskStatus: Type.TUnion<[Type.TLiteral<"waiting">, Type.TLiteral<"queued">, Type.TLiteral<"dispatched">, Type.TLiteral<"running">, Type.TLiteral<"completed">, Type.TLiteral<"failed">, Type.TLiteral<"cancelled">, Type.TLiteral<"expired">]>;
+
+declare type TaskStatus = Static<typeof TaskStatus>;
+
 /**
  * Token / cost accounting for one attempt.
  * Reported by the runtime; persisted per-attempt, also rolled up into
  * `TaskOutput.usage` for convenience.
  */
-declare const TaskUsage: TObject<    {
-    inputTokens: TInteger;
-    outputTokens: TInteger;
-    cacheReadTokens: TOptional<TInteger>;
-    cacheWriteTokens: TOptional<TInteger>;
-    toolCalls: TOptional<TInteger>;
-    model: TOptional<TString>;
-    provider: TOptional<TString>;
+declare const TaskUsage: Type.TObject<{
+    inputTokens: Type.TInteger;
+    outputTokens: Type.TInteger;
+    cacheReadTokens: Type.TOptional<Type.TInteger>;
+    cacheWriteTokens: Type.TOptional<Type.TInteger>;
+    toolCalls: Type.TOptional<Type.TInteger>;
+    model: Type.TOptional<Type.TString>;
+    provider: Type.TOptional<Type.TString>;
 }>;
 
 declare type TaskUsage = Static<typeof TaskUsage>;

package/dist/index.js

@@ -11,8 +11,9 @@ import { Type, getModel } from "@earendil-works/pi-ai";
 import { MemoryProvider, RealFSProvider, ShadowProvider, VM, VmCheckpoint, createHttpHooks, createShadowPathPredicate, ensureImageSelector, loadGuestAssets } from "@earendil-works/gondolin";
 import { parseEnv } from "node:util";
 import { SpanStatusCode, context, metrics, trace } from "@opentelemetry/api";
-import { FormatRegistry, Type as Type$1 } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
+import * as Format from "typebox/format";
+import { Type as Type$1 } from "typebox";
+import { Value } from "typebox/value";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -8929,14 +8930,13 @@ async function resolvePersistentSessionManager(args) {
 * Register TypeBox string formats used across Task / TaskOutput / task-type
 * schemas. Import this module for its side effect (the package index does so
 * automatically) before compiling or Check()ing any schema that references
-* `format: 'uuid'` or `format: 'date-time'` — otherwise TypeCompiler reports
-* "Unknown format" and every union containing such a member fails to match.
+* `format: 'uuid'` or `format: 'date-time'`.
 *
-* Idempotent: registration is guarded by `FormatRegistry.Has(...)`.
+* Idempotent: registration is guarded by `Format.Has(...)`.
 */
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-if (!FormatRegistry.Has("uuid")) FormatRegistry.Set("uuid", (v) => UUID_RE.test(v));
-if (!FormatRegistry.Has("date-time")) FormatRegistry.Set("date-time", (v) => !Number.isNaN(Date.parse(v)));
+if (!Format.Has("uuid")) Format.Set("uuid", (v) => UUID_RE.test(v));
+if (!Format.Has("date-time")) Format.Set("date-time", (v) => !Number.isNaN(Date.parse(v)));
 //#endregion
 //#region ../tasks/src/context.ts
 /**
@@ -10227,10 +10227,22 @@ function formatField(prefix, path) {
 	return path ? `${prefix}${path}` : prefix;
 }
 function schemaErrors(prefix, schema, value) {
-	return [...Value.Errors(schema, value)].map((error) => ({
-		field: formatField(prefix, error.path),
-		message: error.message
-	}));
+	return [...Value.Errors(schema, value)].flatMap((rawError) => {
+		const error = rawError;
+		const baseField = formatField(prefix, error.instancePath);
+		if (error.keyword === "additionalProperties" && error.params?.additionalProperties) return error.params.additionalProperties.map((property) => ({
+			field: `${baseField}/${property}`,
+			message: error.message
+		}));
+		if (error.keyword === "required" && error.params?.requiredProperties) return error.params.requiredProperties.map((property) => ({
+			field: `${baseField}/${property}`,
+			message: `must have required property ${property}`
+		}));
+		return [{
+			field: baseField,
+			message: error.message
+		}];
+	});
 }
 function validateTaskOutput(taskType, output, input) {
 	const entry = getTaskTypeEntry(taskType);
@@ -10352,17 +10364,17 @@ var DaemonState = Type$1.Object({
 	$id: "DaemonState",
 	additionalProperties: false
 });
-var ClaimCondition = Type$1.Recursive((Self) => Type$1.Union([
+var ClaimConditionSchema = Type$1.Union([
 	Type$1.Object({
 		op: Type$1.Literal("all"),
-		conditions: Type$1.Array(Self, {
+		conditions: Type$1.Array(Type$1.Ref("ClaimCondition"), {
 			minItems: 1,
 			maxItems: MAX_CLAIM_CONDITION_BRANCHES
 		})
 	}, { additionalProperties: false }),
 	Type$1.Object({
 		op: Type$1.Literal("any"),
-		conditions: Type$1.Array(Self, {
+		conditions: Type$1.Array(Type$1.Ref("ClaimCondition"), {
 			minItems: 1,
 			maxItems: MAX_CLAIM_CONDITION_BRANCHES
 		})
@@ -10370,7 +10382,7 @@ var ClaimCondition = Type$1.Recursive((Self) => Type$1.Union([
 	Type$1.Object({
 		op: Type$1.Literal("task_status"),
 		taskId: Uuid,
-		statuses: Type$1.Array(Type$1.Ref(TaskStatus), {
+		statuses: Type$1.Array(Type$1.Ref("TaskStatus"), {
 			minItems: 1,
 			maxItems: MAX_CLAIM_CONDITION_STATUSES
 		})
@@ -10379,7 +10391,9 @@ var ClaimCondition = Type$1.Recursive((Self) => Type$1.Union([
 		op: Type$1.Literal("task_accepted"),
 		taskId: Uuid
 	}, { additionalProperties: false })
-]), { $id: "ClaimCondition" });
+], { $id: "ClaimCondition" });
+var ClaimConditionDefinition = Type$1.Unsafe(ClaimConditionSchema);
+Type$1.Unsafe(Type$1.Cyclic({ ClaimCondition: ClaimConditionDefinition }, "ClaimCondition", { $id: "ClaimCondition" }));
 /**
 * Reference to another task's output or an external artifact.
 * Embedded in `tasks.references` JSONB array.
@@ -10461,7 +10475,7 @@ Type$1.Object({
 	proposedByAgentId: Type$1.Union([Uuid, Type$1.Null()]),
 	proposedByHumanId: Type$1.Union([Uuid, Type$1.Null()]),
 	acceptedAttemptN: Type$1.Union([Type$1.Number(), Type$1.Null()]),
-	claimCondition: Type$1.Union([ClaimCondition, Type$1.Null()]),
+	claimCondition: Type$1.Union([Type$1.Unsafe(Type$1.Ref("ClaimCondition")), Type$1.Null()]),
 	requiredExecutorTrustLevel: ExecutorTrustLevel,
 	allowedExecutors: Type$1.Array(ExecutorRef, { maxItems: 16 }),
 	status: TaskStatus,
@@ -15782,7 +15796,7 @@ function createSubagentTool(args) {
 					description: `Submit your structured output for this subagent task. Call exactly once when done. Args MUST match the ${output_schema} contract; mismatches return a tool error you can recover from in the same session.`,
 					parameters: contract.parametersSchema,
 					async execute(_innerId, innerParams) {
-						if (!Value.Check(contract.parametersSchema, innerParams)) return toolError(`submit_subagent_output: schema validation failed: ${[...Value.Errors(contract.parametersSchema, innerParams)].slice(0, 3).map((e) => `${e.path}: ${e.message}`).join("; ")}. Re-call with a corrected payload.`);
+						if (!Value.Check(contract.parametersSchema, innerParams)) return toolError(`submit_subagent_output: schema validation failed: ${[...Value.Errors(contract.parametersSchema, innerParams)].slice(0, 3).map((e) => `${e.instancePath}: ${e.message}`).join("; ")}. Re-call with a corrected payload.`);
 						captured = innerParams;
 						return {
 							content: [{

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@themoltnet/pi-extension",
-  "version": "0.22.2",
+  "version": "0.22.4",
   "type": "module",
   "description": "MoltNet pi extension — sandboxed tool execution in Gondolin VMs with MoltNet identity and persistent memory",
+  "keywords": [
+    "moltnet",
+    "pi-extension",
+    "task-execution"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,9 +35,9 @@
   "dependencies": {
     "@earendil-works/gondolin": "^0.9.1",
     "@opentelemetry/api": "^1.9.0",
-    "@sinclair/typebox": "^0.34.0",
-    "@themoltnet/agent-runtime": "0.22.2",
-    "@themoltnet/sdk": "0.106.0"
+    "typebox": "^1.2.8",
+    "@themoltnet/sdk": "0.106.0",
+    "@themoltnet/agent-runtime": "0.22.4"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.74.0",
@@ -56,8 +61,8 @@
     "vite": "^8.0.0",
     "vite-plugin-dts": "^4.5.4",
     "vitest": "^3.0.0",
-    "@moltnet/crypto-service": "0.1.0",
-    "@moltnet/tasks": "0.1.0"
+    "@moltnet/tasks": "0.1.0",
+    "@moltnet/crypto-service": "0.1.0"
   },
   "engines": {
     "node": ">=22"