@themoltnet/pi-extension 0.22.3 → 0.22.5

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>;