@noetic-tools/types 3.2.0 → 3.2.2

package/dist/schemas/workflow.js

@@ -2,8 +2,8 @@
  * Zod schemas for JSON-serialisable workflow definitions.
  *
  * A `WorkflowDocument` is a portable, JSON-safe representation of a noetic
- * step tree. It covers every step kind. The `run` node carries its body as a
- * code STRING (not an in-process closure) dispatched through a subprocess
+ * step tree. It covers every step kind. The `runCode` node carries its body as
+ * a code STRING (not an in-process closure) dispatched through a subprocess
  * adapter, keeping the document JSON-safe. The hydrator in
  * `@noetic-tools/core` (`builders/workflow-hydrator.ts`) converts a validated
  * document back into live `Step` objects via the existing builders.
@@ -21,11 +21,14 @@ const MaxCostPredicateSchema = z.object({
 });
 const MaxDurationPredicateSchema = z.object({
     kind: z.literal('maxDuration'),
-    ms: z.number().positive(),
+    duration: z.number().positive(),
 });
 const NoToolCallsPredicateSchema = z.object({
     kind: z.literal('noToolCalls'),
 });
+const NeverPredicateSchema = z.object({
+    kind: z.literal('never'),
+});
 const OutputContainsPredicateSchema = z.object({
     kind: z.literal('outputContains'),
     marker: z.string().min(1),
@@ -54,6 +57,7 @@ export const UntilPredicateSchema = z
     MaxCostPredicateSchema,
     MaxDurationPredicateSchema,
     NoToolCallsPredicateSchema,
+    NeverPredicateSchema,
     OutputContainsPredicateSchema,
     OutputEqualsPredicateSchema,
     ConvergedPredicateSchema,
@@ -72,7 +76,7 @@ export const MergeStrategy = {
     First: 'first',
     Concat: 'concat',
 };
-/** @public Zod schema for the named merge strategy used by `fork` nodes. */
+/** @public Zod schema for the named merge strategy used by `inParallel` nodes. */
 export const MergeStrategySchema = z.enum([
     'last',
     'first',
@@ -89,7 +93,7 @@ const ModelParamsSchema = z.object({
 //#endregion
 //#region Tool Entries
 /**
- * A uniform tool entry on an `llm` node. Every entry is an object keyed by
+ * A uniform tool entry on a `callModel` node. Every entry is an object keyed by
  * `type`:
  *   - A CLIENT tool is `{ type: "<registered-tool-name>" }`. The hydrator
  *     resolves `type` against the tool registry; `parameters` (if present) is
@@ -102,13 +106,13 @@ const ModelParamsSchema = z.object({
  * Server vs client is decided by the `type` value (a reserved `openrouter:*`
  * server-tool literal vs an arbitrary tool name), not by the entry's shape.
  */
-const LlmToolEntrySchema = z.object({
+const CallModelToolEntrySchema = z.object({
     type: z.string().min(1),
     parameters: z.record(z.string(), z.unknown()).optional(),
 });
 //#endregion
 //#region Retry Policy
-/** Retry policy for a `run` node, mirroring `RetryPolicy` in `@noetic-tools/types`. */
+/** Retry policy for a `runCode` node, mirroring `RetryPolicy` in `@noetic-tools/types`. */
 const RetryPolicySchema = z.object({
     maxAttempts: z.number().int().positive(),
     backoff: z.enum([
@@ -120,30 +124,84 @@ const RetryPolicySchema = z.object({
     maxDelay: z.number().nonnegative().optional(),
 });
 //#endregion
-//#region SubHarness Settings
-const HarnessSettingsSchema = z.object({
-    model: z.string().optional(),
-    permissionMode: z
-        .enum([
-        'default',
-        'plan',
-        'acceptEdits',
-        'bypassPermissions',
-    ])
-        .optional(),
-    maxTurns: z.number().int().positive().optional(),
-    allowedTools: z.array(z.string()).optional(),
-    extra: z.record(z.string(), z.unknown()).optional(),
+//#region ACP Agent Settings
+/** ACP `ToolKind` — the agent's own classification of a tool call. */
+const AcpToolKindSchema = z.enum([
+    'read',
+    'edit',
+    'delete',
+    'move',
+    'search',
+    'execute',
+    'think',
+    'fetch',
+    'switch_mode',
+    'other',
+]);
+const AcpPermissionDecisionSchema = z.enum([
+    'allow',
+    'deny',
+    'cancel',
+]);
+/**
+ * A permission rule. Both fields are optional matchers; an omitted field
+ * matches anything. `title` is a case-insensitive substring match here — the
+ * programmatic API additionally accepts a `RegExp`, which JSON cannot express.
+ */
+const AcpPermissionRuleSchema = z.object({
+    kind: AcpToolKindSchema.optional(),
+    title: z.string().min(1).optional(),
+});
+const AcpPermissionPolicySchema = z.object({
+    default: AcpPermissionDecisionSchema.optional(),
+    allow: z.array(AcpPermissionRuleSchema).optional(),
+    deny: z.array(AcpPermissionRuleSchema).optional(),
+    persist: z.boolean().optional(),
+});
+const AcpClientCapabilityConfigSchema = z.object({
+    readTextFile: z.boolean().optional(),
+    writeTextFile: z.boolean().optional(),
+    terminal: z.boolean().optional(),
+});
+const AcpNamedValueSchema = z.object({
+    name: z.string(),
+    value: z.string(),
 });
-const HarnessSessionPolicySchema = z.object({
+/** ACP `McpServer`. Stdio is untagged and mandatory for every agent; http/sse are capability-gated. */
+const AcpMcpServerSchema = z.union([
+    z.object({
+        type: z.literal('http'),
+        name: z.string().min(1),
+        url: z.string(),
+        headers: z.array(AcpNamedValueSchema),
+    }),
+    z.object({
+        type: z.literal('sse'),
+        name: z.string().min(1),
+        url: z.string(),
+        headers: z.array(AcpNamedValueSchema),
+    }),
+    z.object({
+        name: z.string().min(1),
+        command: z.string().min(1),
+        args: z.array(z.string()),
+        env: z.array(AcpNamedValueSchema),
+    }),
+]);
+const AcpSessionPolicySchema = z.object({
     reuse: z.string().min(1).optional(),
-    onComplete: z
+    /**
+     * How long the connection is kept alive. Defaults to `step`; `run` and
+     * `harness` are explicit opt-ins because a connection owns a live agent.
+     */
+    keepAlive: z
         .enum([
-        'stop',
-        'detach',
-        'destroy',
+        'step',
+        'run',
+        'harness',
     ])
         .optional(),
+    load: z.string().min(1).optional(),
 });
 //#endregion
 //#region Workflow Node Schema
@@ -155,41 +213,41 @@ const OutputCodecRefSchema = z.object({
     codec: z.literal('openui'),
     library: z.string().min(1),
 });
-const LlmNodeSchema = z.object({
-    kind: z.literal('llm'),
+const CallModelNodeSchema = z.object({
+    kind: z.literal('callModel'),
     ...SHARED_FIELDS,
     model: z.string().optional(),
     instructions: z.string(),
-    tools: z.array(LlmToolEntrySchema).optional(),
+    tools: z.array(CallModelToolEntrySchema).optional(),
     params: ModelParamsSchema.optional(),
     output: OutputCodecRefSchema.optional(),
 });
-const ToolNodeSchema = z.object({
-    kind: z.literal('tool'),
+const InvokeToolNodeSchema = z.object({
+    kind: z.literal('invokeTool'),
     ...SHARED_FIELDS,
     toolName: z.string().min(1),
     args: z.record(z.string(), z.unknown()).optional(),
 });
-const RunNodeSchema = z.object({
-    kind: z.literal('run'),
+const RunCodeNodeSchema = z.object({
+    kind: z.literal('runCode'),
     ...SHARED_FIELDS,
     execute: z.string().min(1),
     retry: RetryPolicySchema.optional(),
     subprocess: z.string().min(1).optional(),
 });
-const BranchRouteSchema = z.object({
+const ConditionalRouteSchema = z.object({
     match: z.string().min(1),
     target: z.lazy(() => WorkflowNodeSchema),
 });
-const BranchNodeSchema = z.object({
-    kind: z.literal('branch'),
+const ConditionalNodeSchema = z.object({
+    kind: z.literal('conditional'),
     ...SHARED_FIELDS,
-    routes: z.array(BranchRouteSchema).min(1),
+    routes: z.array(ConditionalRouteSchema).min(1),
     default: WorkflowNodeRef.optional(),
 });
-const ForkNodeSchema = z
+const InParallelNodeSchema = z
     .object({
-    kind: z.literal('fork'),
+    kind: z.literal('inParallel'),
     ...SHARED_FIELDS,
     mode: z.enum([
         'race',
@@ -203,7 +261,7 @@ const ForkNodeSchema = z
     concurrency: z.number().int().positive().optional(),
 })
     .refine((node) => (node.paths === undefined) !== (node.each === undefined), {
-    message: "fork node requires exactly one of 'paths' (static) or 'each' (dynamic).",
+    message: "inParallel node requires exactly one of 'paths' (static) or 'each' (dynamic).",
 });
 const SpawnNodeSchema = z.object({
     kind: z.literal('spawn'),
@@ -212,8 +270,8 @@ const SpawnNodeSchema = z.object({
     timeout: z.number().positive().optional(),
     layers: z.array(z.string().min(1)).min(1).optional(),
 });
-const ProvideNodeSchema = z.object({
-    kind: z.literal('provide'),
+const WithContextNodeSchema = z.object({
+    kind: z.literal('withContext'),
     ...SHARED_FIELDS,
     child: WorkflowNodeRef,
     layers: z.array(z.string().min(1)).min(1),
@@ -230,11 +288,11 @@ const SequenceNodeSchema = z.object({
     ...SHARED_FIELDS,
     steps: z.array(WorkflowNodeRef).min(1),
 });
-const EveryNodeSchema = z.object({
-    kind: z.literal('every'),
+const ScheduleNodeSchema = z.object({
+    kind: z.literal('schedule'),
     ...SHARED_FIELDS,
     step: WorkflowNodeRef,
-    ms: z.number().nonnegative(),
+    interval: z.number().nonnegative(),
     onError: z
         .enum([
         'continue',
@@ -254,39 +312,34 @@ const SubflowNodeSchema = z
     .refine((node) => (node.document === undefined) !== (node.ref === undefined), {
     message: "subflow node requires exactly one of 'document' (inline) or 'ref' (named).",
 });
-/** Builds the schema for a single harness node kind (`claude-code`, `codex`, …). */
-function subHarnessNodeSchema(kind) {
-    return z.object({
-        kind: z.literal(kind),
-        ...SHARED_FIELDS,
-        prompt: z.string().min(1),
-        instructions: z.string().optional(),
-        settings: HarnessSettingsSchema.optional(),
-        session: HarnessSessionPolicySchema.optional(),
-    });
-}
-const ClaudeCodeNodeSchema = subHarnessNodeSchema('claude-code');
-const CodexNodeSchema = subHarnessNodeSchema('codex');
-const OpencodeNodeSchema = subHarnessNodeSchema('opencode');
-const PiNodeSchema = subHarnessNodeSchema('pi');
+const AcpAgentNodeSchema = z.object({
+    kind: z.literal('acp-agent'),
+    ...SHARED_FIELDS,
+    agent: z.string().min(1),
+    prompt: z.string().min(1),
+    cwd: z.string().min(1).optional(),
+    mode: z.string().min(1).optional(),
+    model: z.string().min(1).optional(),
+    mcpServers: z.array(AcpMcpServerSchema).optional(),
+    permissions: AcpPermissionPolicySchema.optional(),
+    clientCapabilities: AcpClientCapabilityConfigSchema.optional(),
+    session: AcpSessionPolicySchema.optional(),
+});
 /** @public Zod schema validating a single `WorkflowNode` (any JSON-safe kind). */
 export const WorkflowNodeSchema = z
     .discriminatedUnion('kind', [
-    LlmNodeSchema,
-    ToolNodeSchema,
-    RunNodeSchema,
-    BranchNodeSchema,
-    ForkNodeSchema,
+    CallModelNodeSchema,
+    InvokeToolNodeSchema,
+    RunCodeNodeSchema,
+    ConditionalNodeSchema,
+    InParallelNodeSchema,
     SpawnNodeSchema,
-    ProvideNodeSchema,
+    WithContextNodeSchema,
     LoopNodeSchema,
     SequenceNodeSchema,
-    EveryNodeSchema,
+    ScheduleNodeSchema,
     SubflowNodeSchema,
-    ClaudeCodeNodeSchema,
-    CodexNodeSchema,
-    OpencodeNodeSchema,
-    PiNodeSchema,
+    AcpAgentNodeSchema,
 ])
     .meta({
     id: 'WorkflowNode',
@@ -310,7 +363,7 @@ function childNodes(node) {
     switch (node.kind) {
         case 'sequence':
             return node.steps;
-        case 'fork':
+        case 'inParallel':
             if (node.each) {
                 return [
                     node.each,
@@ -318,7 +371,7 @@ function childNodes(node) {
             }
             return node.paths ?? [];
         case 'spawn':
-        case 'provide':
+        case 'withContext':
             return [
                 node.child,
             ];
@@ -326,11 +379,11 @@ function childNodes(node) {
             return [
                 node.body,
             ];
-        case 'every':
+        case 'schedule':
             return [
                 node.step,
             ];
-        case 'branch': {
+        case 'conditional': {
             const children = node.routes.map((r) => r.target);
             if (node.default) {
                 children.push(node.default);
@@ -388,7 +441,7 @@ export function workflowGraph(root) {
 }
 /**
  * Returns the maximum depth of a workflow tree.
- * Leaf nodes (`llm`, `tool`) have depth 0. Structural nodes add +1.
+ * Leaf nodes (`callModel`, `invokeTool`) have depth 0. Structural nodes add +1.
  * A `subflow` ref counts as a leaf — depth does not see through named refs.
  */
 export function workflowDepth(node) {