@deepstrike/wasm 0.2.52 → 0.2.61

package/dist/runtime/types/agent.js

@@ -36,7 +36,7 @@ export function agentRunSpecToKernel(spec) {
             ...(spec.loopRound.defaultAction !== undefined ? { default_action: spec.loopRound.defaultAction } : {}),
         };
     }
-    // Exposure baseline: `undefined` ⇒ omit the field entirely (kernel `None` = legacy behavior);
+    // Exposure baseline: `undefined` ⇒ omit the field entirely (kernel canonical default);
     // `[]` ⇒ send `[]` (kernel `Some([])` = the minimal surface). The unset/minimal distinction is
     // load-bearing, so this is deliberately NOT the `length > 0` idiom `allowedToolIds` uses.
     if (spec.exposureBaseline !== undefined)
@@ -203,6 +203,7 @@ function nodeKindToKernel(n) {
  *  `submit_workflow_nodes` (R3-1) so the two encodings never drift. */
 export function workflowNodeSpecToKernel(n) {
     const kind = nodeKindToKernel(n);
+    const schedulingFactors = schedulingFactorsToKernel(n.schedulingFactors);
     return {
         task: workflowTaskToKernel(n.task),
         role: n.role,
@@ -218,16 +219,41 @@ export function workflowNodeSpecToKernel(n) {
         // O3: per-node turn / wall-clock caps (additive; omitted when unset).
         ...(n.maxTurns != null ? { max_turns: n.maxTurns } : {}),
         ...(n.maxWallMs != null ? { max_wall_ms: n.maxWallMs } : {}),
+        ...(schedulingFactors ? { scheduling_factors: schedulingFactors } : {}),
         ...(n.dependsOn && n.dependsOn.length ? { depends_on: n.dependsOn } : {}),
         dep_policy: n.depPolicy ?? "all_success",
     };
 }
+function schedulingFactorsToKernel(factors) {
+    if (factors === undefined)
+        return undefined;
+    const allowed = new Set(["deadlineUrgency", "processPriority", "resourcePressure", "budgetPressure"]);
+    const unknown = Object.keys(factors).filter(key => !allowed.has(key));
+    if (unknown.length > 0)
+        throw new TypeError(`unknown scheduling factor(s): ${unknown.join(", ")}`);
+    const out = {};
+    for (const [host, kernel] of Object.entries({
+        deadlineUrgency: "deadline_urgency",
+        processPriority: "process_priority",
+        resourcePressure: "resource_pressure",
+        budgetPressure: "budget_pressure",
+    })) {
+        const value = factors[host];
+        if (value !== undefined) {
+            if (!Number.isSafeInteger(value) || value < 0) {
+                throw new RangeError(`schedulingFactors.${host} must be a non-negative safe integer`);
+            }
+            out[kernel] = value;
+        }
+    }
+    return out;
+}
 export function workflowSpecToKernel(spec) {
     return { nodes: spec.nodes.map(workflowNodeSpecToKernel) };
 }
 /** R3-1: the tool a workflow-coordinator node's agent calls to append work to the running DAG. */
 /** Shared JSON-Schema for a workflow-node batch (a DAG). Used by both `submit_workflow_nodes`
- *  (append) and `start_workflow` (M5 v1: author a sub-workflow), so the two tools never drift. */
+ *  (append) and `start_workflow` (workflow authoring: author a sub-workflow), so the two tools never drift. */
 const workflowNodesArraySchema = {
     type: "array",
     items: {
@@ -306,9 +332,9 @@ export const submitWorkflowNodesTool = {
         required: ["nodes"],
     }),
 };
-/** M5 v1 (flatten): the tool an agent calls to author a sub-workflow — a cohesive DAG of nodes
+/** workflow authoring: the tool an agent calls to author a sub-workflow — a cohesive DAG of nodes
  *  composed onto the running workflow. Lowers to the same append path as `submit_workflow_nodes`
- *  (a `WorkflowSpec` is a node batch). v2 adds top-level bootstrap (the `LoadWorkflow` syscall). */
+ *  (a `WorkflowSpec` is a node batch). Top-level bootstrap uses (the `LoadWorkflow` syscall). */
 export const startWorkflowTool = {
     name: "start_workflow",
     description: "Author and run a sub-workflow: a DAG of nodes (fan-out / classify / tournament / loop / reduce) " +

package/dist/runtime/workflow-control-flow.d.ts

@@ -12,10 +12,6 @@ export declare function dependencyOutputsNote(inputAgentIds: string[] | undefine
 export declare function classifyInstruction(labels: string[]): string;
 /** Build a tournament judge's goal: the controller's criterion + the two candidates to compare. */
 export declare function judgeGoal(criterion: string, leftOutput: string, rightOutput: string): string;
-/** Extract a loop stop signal from a loop iteration's output. Returns the `loopContinue` value, or
- *  `undefined` when the agent gave no clear signal (⇒ the kernel runs the loop to `max_iters`).
- *  Accepts `{loop_continue: bool}` or, leniently, `{done: bool}` (continue = !done). */
-export declare function extractLoopContinue(text: string): boolean | undefined;
 /** Extract the chosen branch label from a classifier's output. Prefers `{branch: "..."}`; falls back
  *  to a bare label string that exactly matches one of the valid labels. Returns `undefined` when no
  *  recognizable choice was made (the kernel then prunes every branch — a safe "none matched"). */

package/dist/runtime/workflow-control-flow.js

@@ -45,22 +45,6 @@ export function judgeGoal(criterion, leftOutput, rightOutput) {
         `criterion above.\n\n[CANDIDATE left]\n${leftOutput}\n\n[CANDIDATE right]\n${rightOutput}\n\n` +
         `Respond with ONLY a JSON object: {"winner": "left"} or {"winner": "right"}.`);
 }
-/** Extract a loop stop signal from a loop iteration's output. Returns the `loopContinue` value, or
- *  `undefined` when the agent gave no clear signal (⇒ the kernel runs the loop to `max_iters`).
- *  Accepts `{loop_continue: bool}` or, leniently, `{done: bool}` (continue = !done). */
-export function extractLoopContinue(text) {
-    const v = extractJsonValue(text);
-    if (v && typeof v === "object" && !Array.isArray(v)) {
-        const o = v;
-        if (typeof o.loop_continue === "boolean")
-            return o.loop_continue;
-        if (typeof o.loopContinue === "boolean")
-            return o.loopContinue;
-        if (typeof o.done === "boolean")
-            return !o.done;
-    }
-    return undefined;
-}
 /** Extract the chosen branch label from a classifier's output. Prefers `{branch: "..."}`; falls back
  *  to a bare label string that exactly matches one of the valid labels. Returns `undefined` when no
  *  recognizable choice was made (the kernel then prunes every branch — a safe "none matched"). */

package/dist/types.d.ts

@@ -14,6 +14,34 @@ export interface ContentPart {
     output?: string;
     isError?: boolean;
 }
+export type MediaSource = {
+    kind: "url";
+    url: string;
+} | {
+    kind: "base64";
+    data: string;
+} | {
+    kind: "fileId";
+    id: string;
+    affinity?: {
+        providerId: string;
+        endpointId: string;
+    };
+} | {
+    kind: "object";
+    handle: string;
+    owner?: string;
+    payloadRef?: string;
+};
+export type ToolOutputBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image" | "audio" | "video" | "file";
+    source: MediaSource;
+    mediaType?: string;
+    providerOptions?: Record<string, unknown>;
+};
 export interface Message {
     role: "system" | "user" | "assistant" | "tool";
     content: string;
@@ -36,6 +64,7 @@ export interface ToolResult {
     isFatal?: boolean;
     errorKind?: ToolErrorKind;
     tokenCount?: number;
+    contentParts?: ToolOutputBlock[];
 }
 export interface ToolSchema {
     name: string;
@@ -100,6 +129,7 @@ export interface ToolResultEvent extends StreamEvent {
     isError: boolean;
     isFatal?: boolean;
     errorKind?: ToolErrorKind;
+    contentParts?: ToolOutputBlock[];
 }
 /** R3-1: a workflow node's agent called `submit_workflow_nodes`; the runner surfaces the requested nodes (the workflow lives in the parent kernel) and `runWorkflow` sends them to the parent kernel. */
 export interface WorkflowNodesSubmittedEvent extends StreamEvent {
@@ -165,7 +195,6 @@ export interface ToolArgumentRepairedEvent extends StreamEvent {
 export interface EntropySample {
     turn: number;
     score: number;
-    scoreVersion: number;
     rho: number;
     repeatPressure: number;
     failureRate: number;
@@ -219,10 +248,24 @@ export interface ProviderDescriptor {
         requiresStrictPairing: boolean;
     };
 }
+export type MeasurementSource = {
+    kind: "native";
+    provider: string;
+} | {
+    kind: "local_exact";
+    tokenizer: string;
+} | {
+    kind: "heuristic";
+};
+export type MeasurementConfidence = "exact" | "high_confidence" | "low_confidence";
+export interface PromptMeasurement {
+    inputTokens: number;
+    source: MeasurementSource;
+    confidence: MeasurementConfidence;
+}
 export interface ProviderReplay {
-    schema_version?: 1 | 2;
     provider?: string;
-    protocol?: ProviderProtocol;
+    protocol: ProviderProtocol;
     model?: string;
     native_blocks?: Array<Record<string, unknown>>;
     reasoning_content?: string;
@@ -237,16 +280,26 @@ export interface LLMProvider {
         timeoutMs?: number;
     };
     descriptor?(): ProviderDescriptor;
+    requestPlanIdentity?(): {
+        providerId?: string;
+        modelId?: string;
+        endpoint?: {
+            id?: string;
+            protocol?: string;
+            baseURL?: string;
+        };
+    };
     peekProviderReplay?(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay?(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
+    countTokens?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, 
     /** #2-B-ii: when provided, a preempt (`interrupt()`) aborts the in-flight request. SDK-client
      *  providers forward it via `{ signal }`; the runner also breaks the consume loop on abort, so
-     *  providers that ignore it still stop processing immediately. Optional ⇒ backward-compatible. */
+     *  providers that ignore it still stop processing immediately. */
     signal?: AbortSignal): AsyncIterable<StreamEvent>;
 }
-export interface DreamSummarizer {
+export interface MemorySummarizer {
     summarize(archived: Message[], context: {
         action?: string;
     }): Promise<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.52",
+  "version": "0.2.61",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
     "test:canonical-binding": "wasm-pack build ../crates/deepstrike-wasm --target nodejs --dev --out-dir ../../wasm/pkg-node && node tests/canonical-binding.node.cjs"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.52"
+    "@deepstrike/wasm-kernel": "0.2.61"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",