@deepstrike/sdk 0.2.10 → 0.2.12

package/dist/providers/profiles.js

@@ -35,18 +35,36 @@ export const endpointProfiles = {
         protocol: "openai-chat",
         baseURL: "https://api.minimaxi.com/v1",
     },
+    "deepseek.anthropic": {
+        id: "deepseek.anthropic",
+        providerId: "deepseek",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.deepseek.com/anthropic",
+    },
     "deepseek.openai": {
         id: "deepseek.openai",
         providerId: "deepseek",
         protocol: "openai-chat",
         baseURL: "https://api.deepseek.com",
     },
+    "kimi.anthropic": {
+        id: "kimi.anthropic",
+        providerId: "kimi",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.moonshot.ai/anthropic",
+    },
     "kimi.openai": {
         id: "kimi.openai",
         providerId: "kimi",
         protocol: "openai-chat",
         baseURL: "https://api.moonshot.cn/v1",
     },
+    "qwen.anthropic": {
+        id: "qwen.anthropic",
+        providerId: "qwen",
+        protocol: "anthropic-messages",
+        baseURL: "https://dashscope-intl.aliyuncs.com/apps/anthropic",
+    },
     "qwen.dashscope": {
         id: "qwen.dashscope",
         providerId: "qwen",
@@ -77,6 +95,12 @@ export const endpointProfiles = {
         protocol: "gemini-embeddings",
         baseURL: "https://generativelanguage.googleapis.com",
     },
+    "glm.anthropic": {
+        id: "glm.anthropic",
+        providerId: "glm",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.z.ai/api/anthropic",
+    },
     "glm.openai": {
         id: "glm.openai",
         providerId: "glm",
@@ -375,28 +399,28 @@ export const modelProfiles = {
     },
     // ── DeepSeek ───────────────────────────────────────────────────────────────
     "deepseek/deepseek-chat": {
-        id: "deepseek/deepseek-chat", providerId: "deepseek", defaultEndpointId: "deepseek.openai",
+        id: "deepseek/deepseek-chat", providerId: "deepseek", defaultEndpointId: "deepseek.anthropic",
         contextWindow: 64_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
         policy: { maxTurns: 25 },
     },
     "deepseek/deepseek-reasoner": {
-        id: "deepseek/deepseek-reasoner", providerId: "deepseek", defaultEndpointId: "deepseek.openai",
+        id: "deepseek/deepseek-reasoner", providerId: "deepseek", defaultEndpointId: "deepseek.anthropic",
         contextWindow: 64_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
         policy: { maxTurns: 50 },
     },
     "deepseek/deepseek-v4-flash": {
-        id: "deepseek/deepseek-v4-flash", providerId: "deepseek", defaultEndpointId: "deepseek.openai",
+        id: "deepseek/deepseek-v4-flash", providerId: "deepseek", defaultEndpointId: "deepseek.anthropic",
         contextWindow: 1_000_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
         policy: { maxTurns: 20 },
     },
     "deepseek/deepseek-v4-pro": {
-        id: "deepseek/deepseek-v4-pro", providerId: "deepseek", defaultEndpointId: "deepseek.openai",
+        id: "deepseek/deepseek-v4-pro", providerId: "deepseek", defaultEndpointId: "deepseek.anthropic",
         contextWindow: 1_000_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
@@ -404,48 +428,48 @@ export const modelProfiles = {
     },
     // ── Kimi ───────────────────────────────────────────────────────────────────
     "kimi/moonshot-v1-8k": {
-        id: "kimi/moonshot-v1-8k", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        id: "kimi/moonshot-v1-8k", providerId: "kimi", defaultEndpointId: "kimi.anthropic",
         contextWindow: 8_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
         policy: { maxTurns: 15 },
     },
     "kimi/moonshot-v1-32k": {
-        id: "kimi/moonshot-v1-32k", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        id: "kimi/moonshot-v1-32k", providerId: "kimi", defaultEndpointId: "kimi.anthropic",
         contextWindow: 32_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
         policy: { maxTurns: 20 },
     },
     "kimi/moonshot-v1-128k": {
-        id: "kimi/moonshot-v1-128k", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        id: "kimi/moonshot-v1-128k", providerId: "kimi", defaultEndpointId: "kimi.anthropic",
         contextWindow: 128_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
         policy: { maxTurns: 30 },
     },
     "kimi/kimi-k2.5": {
-        id: "kimi/kimi-k2.5", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        id: "kimi/kimi-k2.5", providerId: "kimi", defaultEndpointId: "kimi.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 30 },
     },
     "kimi/kimi-k2.6": {
-        id: "kimi/kimi-k2.6", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        id: "kimi/kimi-k2.6", providerId: "kimi", defaultEndpointId: "kimi.anthropic",
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 35 },
     },
     "kimi/kimi-k2-thinking": {
-        id: "kimi/kimi-k2-thinking", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        id: "kimi/kimi-k2-thinking", providerId: "kimi", defaultEndpointId: "kimi.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
         policy: { maxTurns: 50 },
     },
     "kimi/kimi-k2-thinking-turbo": {
-        id: "kimi/kimi-k2-thinking-turbo", providerId: "kimi", defaultEndpointId: "kimi.openai",
+        id: "kimi/kimi-k2-thinking-turbo", providerId: "kimi", defaultEndpointId: "kimi.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
@@ -453,91 +477,91 @@ export const modelProfiles = {
     },
     // ── Qwen ───────────────────────────────────────────────────────────────────
     "qwen/qwen3.7-max-preview": {
-        id: "qwen/qwen3.7-max-preview", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.7-max-preview", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 45 },
     },
     "qwen/qwen3.7-plus-preview": {
-        id: "qwen/qwen3.7-plus-preview", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.7-plus-preview", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 1_000_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 40 },
     },
     "qwen/qwen3.6-max-preview": {
-        id: "qwen/qwen3.6-max-preview", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.6-max-preview", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 40 },
     },
     "qwen/qwen3.6-plus": {
-        id: "qwen/qwen3.6-plus", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.6-plus", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 1_000_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 35 },
     },
     "qwen/qwen3.6-flash": {
-        id: "qwen/qwen3.6-flash", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.6-flash", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 1_000_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 20 },
     },
     "qwen/qwen3.6-35b-a3b": {
-        id: "qwen/qwen3.6-35b-a3b", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.6-35b-a3b", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 25 },
     },
     "qwen/qwen3.6-27b": {
-        id: "qwen/qwen3.6-27b", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.6-27b", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 25 },
     },
     "qwen/qwen3.5-plus": {
-        id: "qwen/qwen3.5-plus", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.5-plus", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 1_000_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 35 },
     },
     "qwen/qwen3.5-flash": {
-        id: "qwen/qwen3.5-flash", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.5-flash", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 1_000_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 20 },
     },
     "qwen/qwen3.5-397b-a17b": {
-        id: "qwen/qwen3.5-397b-a17b", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.5-397b-a17b", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 35 },
     },
     "qwen/qwen3.5-122b-a10b": {
-        id: "qwen/qwen3.5-122b-a10b", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.5-122b-a10b", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 25 },
     },
     "qwen/qwen3.5-35b-a3b": {
-        id: "qwen/qwen3.5-35b-a3b", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.5-35b-a3b", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
         policy: { maxTurns: 20 },
     },
     "qwen/qwen3.5-27b": {
-        id: "qwen/qwen3.5-27b", providerId: "qwen", defaultEndpointId: "qwen.dashscope",
+        id: "qwen/qwen3.5-27b", providerId: "qwen", defaultEndpointId: "qwen.anthropic",
         contextWindow: 256_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: false },
@@ -645,28 +669,28 @@ export const modelProfiles = {
     },
     // ── GLM ────────────────────────────────────────────────────────────────────
     "glm/glm-5.1": {
-        id: "glm/glm-5.1", providerId: "glm", defaultEndpointId: "glm.openai",
+        id: "glm/glm-5.1", providerId: "glm", defaultEndpointId: "glm.anthropic",
         contextWindow: 200_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: true, preserveAcrossToolTurns: true },
         policy: { maxTurns: 50 },
     },
     "glm/glm-4-plus": {
-        id: "glm/glm-4-plus", providerId: "glm", defaultEndpointId: "glm.openai",
+        id: "glm/glm-4-plus", providerId: "glm", defaultEndpointId: "glm.anthropic",
         contextWindow: 128_000,
         modalities: { input: ["text", "image"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
         policy: { maxTurns: 35 },
     },
     "glm/glm-4-flash": {
-        id: "glm/glm-4-flash", providerId: "glm", defaultEndpointId: "glm.openai",
+        id: "glm/glm-4-flash", providerId: "glm", defaultEndpointId: "glm.anthropic",
         contextWindow: 128_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },
         policy: { maxTurns: 15 },
     },
     "glm/glm-4-air": {
-        id: "glm/glm-4-air", providerId: "glm", defaultEndpointId: "glm.openai",
+        id: "glm/glm-4-air", providerId: "glm", defaultEndpointId: "glm.anthropic",
         contextWindow: 128_000,
         modalities: { input: ["text"], output: ["text"] },
         tools: { supported: true }, reasoning: { supported: false, preserveAcrossToolTurns: false },

package/dist/providers/qwen.d.ts

@@ -1,7 +1,19 @@
 import OpenAI from "openai";
 import type { LLMProvider, Message, ProviderDescriptor, RenderedContext, StreamEvent, ToolSchema, RuntimePolicy, ProviderReplay } from "../types.js";
+import { AnthropicProvider } from "./anthropic.js";
 import { CircuitBreaker } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
+/**
+ * Qwen over its Anthropic-compatible endpoint.
+ */
+export declare class QwenAnthropicProvider extends AnthropicProvider {
+    constructor(apiKey: string, model?: string, retry?: {
+        maxRetries: number;
+        baseDelay: number;
+    }, baseURL?: string);
+    protected providerName(): string;
+    runtimePolicy(): RuntimePolicy;
+}
 export declare class QwenProvider implements LLMProvider {
     protected readonly model: string;
     protected client: OpenAI;

package/dist/providers/qwen.js

@@ -1,9 +1,9 @@
 import OpenAI from "openai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker, omitExtensionKeys } from "./base.js";
+import { AnthropicProvider } from "./anthropic.js";
+import { CircuitBreaker, omitExtensionKeys, openAICachedPromptTokens } from "./base.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
 import { endpointProfiles } from "./profiles.js";
-const QWEN_BASE = endpointProfiles["qwen.dashscope"].baseURL;
 const QWEN_POLICIES = {
     "qwen3.7-max-preview": { maxTurns: 45 },
     "qwen3.7-plus-preview": { maxTurns: 40 },
@@ -19,6 +19,23 @@ const QWEN_POLICIES = {
     "qwen3.5-35b-a3b": { maxTurns: 20 },
     "qwen3.5-27b": { maxTurns: 20 },
 };
+/**
+ * Qwen over its Anthropic-compatible endpoint.
+ */
+export class QwenAnthropicProvider extends AnthropicProvider {
+    constructor(apiKey, model = "qwen3.6-plus", retry, baseURL = endpointProfiles["qwen.anthropic"].baseURL) {
+        super(apiKey, model, retry, {
+            baseURL,
+            authMode: "api-key",
+        });
+    }
+    providerName() {
+        return "qwen";
+    }
+    runtimePolicy() {
+        return QWEN_POLICIES[this.model] ?? {};
+    }
+}
 export class QwenProvider {
     model;
     client;
@@ -26,7 +43,7 @@ export class QwenProvider {
     maxRetries;
     baseDelay;
     chat = new OpenAIChatAdapter();
-    constructor(apiKey, model = "qwen3.6-plus", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = QWEN_BASE) {
+    constructor(apiKey, model = "qwen3.6-plus", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = endpointProfiles["qwen.dashscope"].baseURL) {
         this.model = model;
         this.client = withServerRuntimeGuard(() => new OpenAI({ apiKey, baseURL }));
         this.circuit = new CircuitBreaker();
@@ -113,11 +130,13 @@ export class QwenProvider {
         let totalTokens = 0;
         let inputTokens = 0;
         let outputTokens = 0;
+        let cacheReadTokens = 0;
         for await (const chunk of stream) {
             if (chunk.usage) {
                 totalTokens = chunk.usage.total_tokens;
                 inputTokens = chunk.usage.prompt_tokens ?? 0;
                 outputTokens = chunk.usage.completion_tokens ?? 0;
+                cacheReadTokens = openAICachedPromptTokens(chunk.usage);
                 continue;
             }
             const choice = chunk.choices[0];
@@ -184,7 +203,7 @@ export class QwenProvider {
             yield { type: "tool_call", id: tb.id, name: tb.name, arguments: args };
         }
         if (totalTokens > 0)
-            yield { type: "usage", totalTokens, inputTokens, outputTokens };
+            yield { type: "usage", totalTokens, inputTokens, outputTokens, ...(cacheReadTokens > 0 ? { cacheReadInputTokens: cacheReadTokens } : {}) };
     }
     thinkingExtraBody(extensions) {
         const enableThinking = Boolean(extensions?.enableThinking ?? extensions?.enable_thinking);

package/dist/runtime/output-schema.d.ts

@@ -0,0 +1,14 @@
+export interface SchemaValidation {
+    ok: boolean;
+    errors: string[];
+}
+type JsonSchema = Record<string, unknown>;
+/** Validate `value` against `schema` (the supported subset). `path` is for error messages. */
+export declare function validateAgainstSchema(value: unknown, schema: JsonSchema, path?: string): SchemaValidation;
+/** The instruction appended to a node's goal so its agent produces schema-conforming JSON. */
+export declare function schemaInstruction(schema: JsonSchema): string;
+/** A stronger re-prompt for a retry after a validation failure. */
+export declare function schemaRetryInstruction(schema: JsonSchema, errors: string[]): string;
+/** Best-effort extraction of a JSON value from agent output (raw, fenced, or embedded). */
+export declare function extractJsonValue(text: string): unknown;
+export {};

package/dist/runtime/output-schema.js

@@ -0,0 +1,113 @@
+// G3 structured output: a small, dependency-free JSON-Schema subset validator + helpers used by the
+// workflow runner to enforce a node's `output_schema`. The kernel carries the schema verbatim (it is
+// zero-I/O and never validates); enforcement lives here, SDK-side, where the agent output exists.
+//
+// Supported keywords (the common structured-output subset): `type` (object | array | string |
+// number | integer | boolean | null), `required`, `properties` (recursive), `items` (recursive),
+// `enum`. Unknown keywords are ignored rather than rejected — a permissive superset of these specs
+// still validates, matching "instruct the model, then check the shape" rather than full JSON Schema.
+function typeOfValue(v) {
+    if (v === null)
+        return "null";
+    if (Array.isArray(v))
+        return "array";
+    return typeof v; // "object" | "string" | "number" | "boolean"
+}
+function matchesType(v, t) {
+    switch (t) {
+        case "integer":
+            return typeof v === "number" && Number.isInteger(v);
+        case "number":
+            return typeof v === "number";
+        case "object":
+            return typeOfValue(v) === "object";
+        default:
+            return typeOfValue(v) === t;
+    }
+}
+/** Validate `value` against `schema` (the supported subset). `path` is for error messages. */
+export function validateAgainstSchema(value, schema, path = "$") {
+    const errors = [];
+    const type = schema.type;
+    if (typeof type === "string" && !matchesType(value, type)) {
+        errors.push(`${path}: expected ${type}, got ${typeOfValue(value)}`);
+        return { ok: false, errors }; // type mismatch ⇒ stop; deeper checks are meaningless
+    }
+    if (Array.isArray(type) && !type.some(t => typeof t === "string" && matchesType(value, t))) {
+        errors.push(`${path}: expected one of [${type.join(", ")}], got ${typeOfValue(value)}`);
+        return { ok: false, errors };
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.some(e => e === value)) {
+        errors.push(`${path}: value not in enum`);
+    }
+    if (typeOfValue(value) === "object") {
+        const obj = value;
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        for (const key of required) {
+            if (!(key in obj))
+                errors.push(`${path}.${key}: required property missing`);
+        }
+        const properties = schema.properties ?? {};
+        for (const [key, sub] of Object.entries(properties)) {
+            if (key in obj) {
+                const r = validateAgainstSchema(obj[key], sub, `${path}.${key}`);
+                if (!r.ok)
+                    errors.push(...r.errors);
+            }
+        }
+    }
+    if (typeOfValue(value) === "array" && schema.items && typeof schema.items === "object") {
+        const items = schema.items;
+        value.forEach((el, i) => {
+            const r = validateAgainstSchema(el, items, `${path}[${i}]`);
+            if (!r.ok)
+                errors.push(...r.errors);
+        });
+    }
+    return { ok: errors.length === 0, errors };
+}
+/** The instruction appended to a node's goal so its agent produces schema-conforming JSON. */
+export function schemaInstruction(schema) {
+    return ("You MUST return ONLY a single JSON value that conforms to this JSON Schema, with no prose, " +
+        "no markdown, and no code fences:\n" +
+        JSON.stringify(schema));
+}
+/** A stronger re-prompt for a retry after a validation failure. */
+export function schemaRetryInstruction(schema, errors) {
+    return (`${schemaInstruction(schema)}\n\nYour previous output did NOT conform: ${errors.join("; ")}. ` +
+        "Return ONLY the corrected JSON value.");
+}
+/** Best-effort extraction of a JSON value from agent output (raw, fenced, or embedded). */
+export function extractJsonValue(text) {
+    const trimmed = (text ?? "").trim();
+    if (!trimmed)
+        return undefined;
+    const tryParse = (s) => {
+        try {
+            return JSON.parse(s);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const whole = tryParse(trimmed);
+    if (whole !== undefined)
+        return whole;
+    const fence = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fence) {
+        const fenced = tryParse(fence[1].trim());
+        if (fenced !== undefined)
+            return fenced;
+    }
+    // Fall back to the first balanced {...} or [...] slice.
+    for (const [open, close] of [["{", "}"], ["[", "]"]]) {
+        const start = trimmed.indexOf(open);
+        const end = trimmed.lastIndexOf(close);
+        if (start !== -1 && end > start) {
+            const slice = tryParse(trimmed.slice(start, end + 1));
+            if (slice !== undefined)
+                return slice;
+        }
+    }
+    return undefined;
+}

package/dist/runtime/reducers.d.ts

@@ -0,0 +1,15 @@
+/** One dependency's contribution to a reduce: the producing node's agent id and its output text. */
+export interface ReducerInput {
+    agentId: string;
+    output: string;
+}
+/** A pure function over a reduce node's dependency outputs → the reduce node's output string. */
+export type Reducer = (inputs: ReducerInput[]) => string;
+export type ReducerRegistry = Record<string, Reducer>;
+/**
+ * Built-in reducers, available to every workflow without registration. A user-supplied registry is
+ * merged over these (so a custom reducer can shadow a built-in of the same name).
+ */
+export declare const builtinReducers: ReducerRegistry;
+/** Resolve a reducer by name from the built-ins overlaid with a user registry. */
+export declare function resolveReducer(name: string, user?: ReducerRegistry): Reducer | undefined;

package/dist/runtime/reducers.js

@@ -0,0 +1,57 @@
+// G2 deterministic compute: the host-side reducer registry. A `NodeKind::Reduce` workflow node runs
+// no LLM agent — the kernel hands the SDK a reducer name + its dependency outputs, and the SDK runs
+// the named pure function here. This is the "ordinary code between stages" (dedupe / filter / merge /
+// early-exit) of the code-orchestration model, expressed deterministically as a DAG node.
+import { extractJsonValue } from "./output-schema.js";
+/** Non-empty, trimmed lines of a string. */
+function lines(s) {
+    return s
+        .split("\n")
+        .map(l => l.trim())
+        .filter(l => l.length > 0);
+}
+/**
+ * Built-in reducers, available to every workflow without registration. A user-supplied registry is
+ * merged over these (so a custom reducer can shadow a built-in of the same name).
+ */
+export const builtinReducers = {
+    /** Concatenate every input's output, separated by blank lines, in dependency order. */
+    concat: inputs => inputs.map(i => i.output).join("\n\n"),
+    /** Union of non-empty lines across all inputs, first-seen order preserved (dedupe a fan-out). */
+    dedupe_lines: inputs => {
+        const seen = new Set();
+        const out = [];
+        for (const i of inputs) {
+            for (const line of lines(i.output)) {
+                if (!seen.has(line)) {
+                    seen.add(line);
+                    out.push(line);
+                }
+            }
+        }
+        return out.join("\n");
+    },
+    /** Parse each input as a JSON array, concatenate, dedupe by canonical JSON → a JSON array string. */
+    merge_json_arrays: inputs => {
+        const seen = new Set();
+        const merged = [];
+        for (const i of inputs) {
+            const v = extractJsonValue(i.output);
+            const arr = Array.isArray(v) ? v : v !== undefined ? [v] : [];
+            for (const el of arr) {
+                const key = JSON.stringify(el);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    merged.push(el);
+                }
+            }
+        }
+        return JSON.stringify(merged);
+    },
+    /** The number of inputs that produced any non-empty output — handy for early-exit/branch gates. */
+    count: inputs => String(inputs.filter(i => i.output.trim().length > 0).length),
+};
+/** Resolve a reducer by name from the built-ins overlaid with a user registry. */
+export function resolveReducer(name, user) {
+    return user?.[name] ?? builtinReducers[name];
+}

package/dist/runtime/runner.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, Message, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, DreamSummarizer } from "../types.js";
+import type { LLMProvider, Message, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, DreamSummarizer } from "../types.js";
 import type { DreamStore, MemoryEntry, MemoryQuery, MemoryWriteRequest } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
 import type { SignalSource } from "../signals/types.js";
@@ -8,6 +8,7 @@ import type { ExecutionPlane } from "./execution-plane.js";
 import { type MemoryPolicy, type ResourceQuota } from "../kernel.js";
 import type { AgentRunSpec, MilestoneCheckResult, MilestoneContract, MilestonePolicy, WorkflowSpec } from "../types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
+import { type ReducerRegistry } from "./reducers.js";
 import { type GovernancePolicy } from "../governance.js";
 import { type NativeOsProfile, type OsProfileId } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
@@ -97,6 +98,9 @@ export interface RuntimeOptions {
         evalProvider: LLMProvider;
         maxAttempts?: number;
     };
+    /** G2: custom reducers for `NodeKind::Reduce` workflow nodes, merged over the built-ins
+     *  (`concat` / `dedupe_lines` / `merge_json_arrays` / `count`). A reduce node runs no LLM. */
+    reducers?: ReducerRegistry;
     /** Optional system prompt injected into the dream synthesis call. */
     dreamSystemPrompt?: string;
     /** Custom LLM provider used for background memory consolidation (dream loop). */
@@ -159,6 +163,22 @@ export declare class RuntimeRunner {
      * Requires an active parent run (`run()` / `wake()` in progress or paused at milestone).
      */
     spawnSubAgent(spec: AgentRunSpec): AsyncIterable<StreamEvent>;
+    /**
+     * G3: run one workflow node, enforcing its `output_schema` (if any). Without a schema this is a
+     * plain `orchestrator.run`. With one, the node's agent is instructed to emit conforming JSON, its
+     * output is validated (the supported JSON-Schema subset), and on mismatch the node is re-run once
+     * with the validation errors fed back. If it still does not conform, the node is failed with the
+     * validation reason — a node that cannot meet its declared output contract starves its dependents,
+     * exactly as a denied spawn does.
+     */
+    private runWorkflowNode;
+    /**
+     * G2: execute a deterministic reduce node. Looks up the named reducer (built-ins overlaid with
+     * `opts.reducers`), runs it over the node's dependency outputs (gathered from `outputs`), and
+     * returns a synthetic completion carrying the reducer's output — no LLM, zero tokens. An unknown
+     * reducer or a thrown reducer fails the node (`Error` termination → the kernel starves dependents).
+     */
+    private runReduceNode;
     /**
      * W0-ABI: run a declarative workflow DAG. The kernel owns the DAG and gates every node spawn
      * through the syscall trap; this driver runs each kernel-emitted batch of nodes in parallel,
@@ -167,6 +187,7 @@ export declare class RuntimeRunner {
      */
     runWorkflow(spec: WorkflowSpec, opts?: {
         resumedCompleted?: string[];
+        resumedSubmissions?: Record<string, unknown>[][];
     }): Promise<{
         completed: string[];
         failed: string[];
@@ -185,6 +206,8 @@ export declare class RuntimeRunner {
         sessionId: string;
         goal: string;
         criteria?: string[];
+        /** Multimodal inputs (images / audio) attached to the task as a user message. */
+        attachments?: ContentPart[];
         extensions?: Record<string, unknown>;
         /** Parent transcript to preload (e.g. sub-agent full context inheritance). */
         inheritEvents?: Array<{