@diffexai/diffex 0.3.1 → 0.3.2

package/dist/core/tools/update-plan.js

@@ -9,26 +9,34 @@ const updatePlanStatusSchema = Type.Unsafe({
     description: "Status of this plan item.",
 });
 const updatePlanItemSchema = Type.Object({
+    id: Type.String({ description: "Stable step ID; retain it across edits and reordering." }),
     step: Type.String({ description: "Task step text." }),
     status: updatePlanStatusSchema,
+    success_criteria: Type.Optional(Type.Array(Type.String(), { description: "Observable completion criteria." })),
 }, { additionalProperties: false });
 const updatePlanSchema = Type.Object({
     plan: Type.Optional(Type.Array(updatePlanItemSchema, {
         minItems: 1,
-        description: "Full ordered plan snapshot. Provide exactly one operation: plan or clear.",
+        description: "Full ordered plan snapshot. Keep existing IDs for retained steps.",
     })),
+    update: Type.Optional(Type.Object({
+        id: Type.String({ description: "ID of an existing step." }),
+        step: Type.Optional(Type.String()),
+        status: Type.Optional(updatePlanStatusSchema),
+        success_criteria: Type.Optional(Type.Array(Type.String())),
+    }, { additionalProperties: false })),
     clear: Type.Optional(Type.Literal(true, {
-        description: "Explicitly abandon and clear the current plan. Provide exactly one operation: plan or clear.",
+        description: "Explicitly abandon and clear the current plan.",
     })),
     explanation: Type.Optional(Type.String({ description: "Reason for changing or clearing the plan." })),
 }, { additionalProperties: false });
 export const updatePlanToolSystemPromptContribution = {
-    snippet: "track progress with an ordered task checklist",
+    snippet: "persist an ordered plan with step IDs and optional success criteria",
     guidelines: [
         "Use update_plan for complex, ambiguous, dependent, long-running, or multi-part work, when the user requests a plan, or when checkpoints would improve collaboration; skip it for simple or immediately executable work.",
-        "Write short, ordered, outcome-focused steps with observable evidence where useful; do not narrate commands or pad the checklist with obvious actions.",
+        "Write short, ordered, outcome-focused steps. Give each step a stable ID and add optional success_criteria for subtasks needing validation.",
         "Include final verification when correctness requires it.",
-        "Update the checklist at meaningful milestones and mark completed work before moving on.",
+        "Update by ID at meaningful milestones; retain IDs when rewording, reordering, or changing status.",
         "Explain material replanning, omit explanations for routine progress, and use clear: true only when abandoning the checklist.",
         "Publishing the checklist communicates progress but does not execute, schedule, or prove completion of its steps.",
     ],
@@ -39,28 +47,52 @@ function isRecord(value) {
 function isUpdatePlanStatus(value) {
     return typeof value === "string" && UPDATE_PLAN_STATUSES.includes(value);
 }
+function validateCriteria(value, label) {
+    if (!Array.isArray(value) ||
+        value.some((criterion) => typeof criterion !== "string" || criterion.trim().length === 0)) {
+        throw new Error(`${label} must be an array of non-empty strings.`);
+    }
+    return [...value];
+}
 function validatePlanSnapshot(rawPlan) {
     if (!Array.isArray(rawPlan) || rawPlan.length === 0) {
         throw new Error("Plan must contain at least one item.");
     }
     const plan = [];
+    const ids = new Set();
     for (let index = 0; index < rawPlan.length; index++) {
         const rawItem = rawPlan[index];
         if (!isRecord(rawItem)) {
             throw new Error(`Plan item ${index + 1} must be an object.`);
         }
-        const unexpectedField = Object.keys(rawItem).find((field) => field !== "step" && field !== "status");
+        const unexpectedField = Object.keys(rawItem).find((field) => field !== "id" && field !== "step" && field !== "status" && field !== "success_criteria");
         if (unexpectedField !== undefined) {
             throw new Error(`Plan item ${index + 1} contains unexpected field: ${unexpectedField}.`);
         }
-        const { step, status } = rawItem;
+        const { id, step, status } = rawItem;
+        if (typeof id !== "string" || id.trim().length === 0) {
+            throw new Error(`Plan item ${index + 1} id must be a non-empty string.`);
+        }
+        if (ids.has(id)) {
+            throw new Error(`Duplicate plan item id: ${id}.`);
+        }
+        ids.add(id);
         if (typeof step !== "string" || step.trim().length === 0) {
             throw new Error(`Plan item ${index + 1} step must be a non-empty string.`);
         }
         if (!isUpdatePlanStatus(status)) {
             throw new Error(`Plan item ${index + 1} status must be pending, in_progress, or completed.`);
         }
-        plan.push({ step, status });
+        plan.push({
+            id,
+            step,
+            status,
+            ...(Object.hasOwn(rawItem, "success_criteria")
+                ? {
+                    success_criteria: validateCriteria(rawItem.success_criteria, `Plan item ${index + 1} success_criteria`),
+                }
+                : {}),
+        });
     }
     const counts = countPlanStatuses(plan);
     if (counts.completed !== plan.length && counts.inProgress !== 1) {
@@ -72,14 +104,15 @@ export function parseUpdatePlanOperation(input) {
     if (!isRecord(input)) {
         throw new Error("update_plan input must be an object.");
     }
-    const unexpectedField = Object.keys(input).find((field) => field !== "plan" && field !== "clear" && field !== "explanation");
+    const unexpectedField = Object.keys(input).find((field) => field !== "plan" && field !== "update" && field !== "clear" && field !== "explanation");
     if (unexpectedField !== undefined) {
         throw new Error(`Unexpected update_plan field: ${unexpectedField}.`);
     }
     const hasPlan = Object.hasOwn(input, "plan");
+    const hasUpdate = Object.hasOwn(input, "update");
     const hasClear = Object.hasOwn(input, "clear");
-    if (hasPlan === hasClear) {
-        throw new Error("Provide exactly one update_plan operation: plan or clear.");
+    if (Number(hasPlan) + Number(hasUpdate) + Number(hasClear) !== 1) {
+        throw new Error("Provide exactly one update_plan operation: plan, update, or clear.");
     }
     const hasExplanation = Object.hasOwn(input, "explanation");
     if (hasExplanation && typeof input.explanation !== "string") {
@@ -92,9 +125,64 @@ export function parseUpdatePlanOperation(input) {
         }
         return hasExplanation ? { clear: true, explanation } : { clear: true };
     }
+    if (hasUpdate) {
+        if (!isRecord(input.update))
+            throw new Error("Update must be an object.");
+        const unexpectedUpdateField = Object.keys(input.update).find((field) => field !== "id" && field !== "step" && field !== "status" && field !== "success_criteria");
+        if (unexpectedUpdateField !== undefined)
+            throw new Error(`Unexpected update field: ${unexpectedUpdateField}.`);
+        const { id, step, status } = input.update;
+        if (typeof id !== "string" || id.trim().length === 0)
+            throw new Error("Update id must be a non-empty string.");
+        if (step !== undefined && (typeof step !== "string" || step.trim().length === 0)) {
+            throw new Error("Update step must be a non-empty string.");
+        }
+        if (status !== undefined && !isUpdatePlanStatus(status)) {
+            throw new Error("Update status must be pending, in_progress, or completed.");
+        }
+        const hasCriteria = Object.hasOwn(input.update, "success_criteria");
+        if (step === undefined && status === undefined && !hasCriteria)
+            throw new Error("Update must change a step field.");
+        const update = {
+            id,
+            ...(step === undefined ? {} : { step }),
+            ...(status === undefined ? {} : { status }),
+            ...(hasCriteria
+                ? { success_criteria: validateCriteria(input.update.success_criteria, "Update success_criteria") }
+                : {}),
+        };
+        return hasExplanation ? { update, explanation } : { update };
+    }
     const plan = validatePlanSnapshot(input.plan);
     return hasExplanation ? { plan, explanation } : { plan };
 }
+export function resolveUpdatePlanOperation(input, currentPlan) {
+    const operation = parseUpdatePlanOperation(input);
+    if (!("update" in operation))
+        return operation;
+    if (!currentPlan)
+        throw new Error("Cannot update a step without a current plan.");
+    const index = currentPlan.findIndex((item) => item.id === operation.update.id);
+    if (index < 0)
+        throw new Error(`Unknown plan step id: ${operation.update.id}.`);
+    const plan = currentPlan.map((item, itemIndex) => {
+        if (itemIndex !== index)
+            return item;
+        const { success_criteria, ...changes } = operation.update;
+        const updated = { ...item, ...changes };
+        if (success_criteria !== undefined) {
+            if (success_criteria.length === 0)
+                delete updated.success_criteria;
+            else
+                updated.success_criteria = success_criteria;
+        }
+        return updated;
+    });
+    return {
+        plan: validatePlanSnapshot(plan),
+        ...(operation.explanation === undefined ? {} : { explanation: operation.explanation }),
+    };
+}
 function countPlanStatuses(plan) {
     let completed = 0;
     let inProgress = 0;
@@ -151,27 +239,43 @@ function formatPlanCall(args, theme, showInvalidArgs) {
     if ("clear" in details) {
         return `${text}\n${theme.fg("toolOutput", "Plan cleared.")}`;
     }
+    if ("update" in details) {
+        text += `\n${theme.fg("toolOutput", `Update ${details.update.id}`)}`;
+        if (details.update.status)
+            text += ` ${formatPlanMarker(details.update.status, theme)}`;
+        if (details.update.step)
+            text += ` ${formatPlanStep(details.update.step, theme)}`;
+        if (details.update.success_criteria) {
+            for (const criterion of details.update.success_criteria)
+                text += `\n  ${theme.fg("toolOutput", `- ${criterion}`)}`;
+        }
+        return text;
+    }
     for (const item of details.plan) {
-        text += `\n${formatPlanMarker(item.status, theme)} ${formatPlanStep(item.step, theme)}`;
+        text += `\n${formatPlanMarker(item.status, theme)} ${theme.fg("toolOutput", item.id)} ${formatPlanStep(item.step, theme)}`;
+        for (const criterion of item.success_criteria ?? [])
+            text += `\n  ${theme.fg("toolOutput", `- ${criterion}`)}`;
     }
     return text;
 }
-export function createUpdatePlanToolDefinition() {
+export function createUpdatePlanToolDefinition(_cwd, getCurrentPlan) {
     return {
         name: "update_plan",
         label: "update_plan",
-        description: "Replace or explicitly clear the full ordered task checklist. Unfinished plans require exactly one in_progress item.",
+        description: "Write or clear a plan, or update one step by ID. Use optional success_criteria for validation.",
         promptSnippet: updatePlanToolSystemPromptContribution.snippet,
         promptGuidelines: [...updatePlanToolSystemPromptContribution.guidelines],
         parameters: updatePlanSchema,
         executionMode: "sequential",
         async execute(_toolCallId, input) {
-            const details = parseUpdatePlanOperation(input);
+            const details = resolveUpdatePlanOperation(input, getCurrentPlan?.());
             return {
                 content: [
                     {
                         type: "text",
-                        text: "clear" in details ? "Plan cleared." : formatPlanSummary(details.plan),
+                        text: "clear" in details
+                            ? "Plan cleared."
+                            : `${formatPlanSummary(details.plan)}\n${JSON.stringify({ plan: details.plan }, null, 2)}`,
                     },
                 ],
                 details,
@@ -188,6 +292,6 @@ export function createUpdatePlanToolDefinition() {
         },
     };
 }
-export function createUpdatePlanTool() {
-    return wrapToolDefinition(createUpdatePlanToolDefinition());
+export function createUpdatePlanTool(getCurrentPlan) {
+    return wrapToolDefinition(createUpdatePlanToolDefinition(undefined, getCurrentPlan));
 }

package/dist/modes/interactive/components/footer.js

@@ -131,6 +131,11 @@ export class FooterComponent {
         const contextFull = theme.fg("footerContext", `context ${contextPercent}%`) +
             theme.fg("borderMuted", " / ") +
             theme.fg("footerWindow", windowDisplay);
+        const { input, cacheRead, cacheWrite } = this.session.getSessionStats().tokens;
+        const promptTokens = input + cacheRead + cacheWrite;
+        const cacheHitPercent = promptTokens > 0 && (cacheRead > 0 || cacheWrite > 0)
+            ? `${((cacheRead / promptTokens) * 100).toFixed(1)}%`
+            : undefined;
         const planMode = getCollaborationMode(this.session) === "plan";
         const planFull = theme.fg("warning", "Plan mode");
         const planCompact = theme.fg("warning", "Plan");
@@ -176,6 +181,9 @@ export class FooterComponent {
         };
         const tryAddField = (field) => trySetFields([...fields, field]);
         const tryUpgradeField = (key, text) => trySetFields(fields.map((field) => (field.key === key ? { ...field, text } : field)));
+        if (cacheHitPercent !== undefined) {
+            tryAddField({ key: "cache", order: 3, text: theme.fg("dim", `cache ${cacheHitPercent}`) });
+        }
         // Extension statuses are public UI state, so admit them before optional
         // detail upgrades and shortcut hints. Truncate only their own field.
         const extensionStatuses = this.footerData.getExtensionStatuses();
@@ -189,7 +197,7 @@ export class FooterComponent {
             if (statusText.length > 0 && availableWidth > 0) {
                 tryAddField({
                     key: "extensions",
-                    order: 4,
+                    order: 5,
                     text: truncateToWidth(theme.fg("dim", statusText), availableWidth, glyphs.ellipsis),
                 });
             }
@@ -197,14 +205,17 @@ export class FooterComponent {
         tryAddField({ key: "thinking", order: 1, text: theme.fg("thinkingText", thinkingLevel) });
         tryAddField({
             key: "harness",
-            order: 3,
+            order: 4,
             text: theme.fg("dim", `h:${harnessVersion}`) + evolutionSpinner,
         });
         tryUpgradeField("context", contextMedium);
         tryUpgradeField("thinking", theme.fg("thinkingText", `thinking ${thinkingLevel}`));
+        if (cacheHitPercent !== undefined) {
+            tryUpgradeField("cache", theme.fg("dim", `input cache hit ${cacheHitPercent}`));
+        }
         tryUpgradeField("harness", theme.fg("dim", `harness ${harnessVersion}`) + evolutionSpinner);
         tryUpgradeField("context", contextFull);
-        tryAddField({ key: "hotkeys", order: 7, text: theme.fg("dim", "/hotkeys") });
+        tryAddField({ key: "hotkeys", order: 8, text: theme.fg("dim", "/hotkeys") });
         const getBindingHint = (action, label) => {
             try {
                 const binding = keyText(action);
@@ -216,11 +227,11 @@ export class FooterComponent {
         };
         const thinkingHint = getBindingHint("app.thinking.cycle", "thinking");
         if (thinkingHint) {
-            tryAddField({ key: "thinkingHint", order: 5, text: thinkingHint });
+            tryAddField({ key: "thinkingHint", order: 6, text: thinkingHint });
         }
         const modelHint = getBindingHint("app.model.cycleForward", "model");
         if (modelHint) {
-            tryAddField({ key: "modelHint", order: 6, text: modelHint });
+            tryAddField({ key: "modelHint", order: 7, text: modelHint });
         }
         return [renderFields(fields)];
     }

package/dist/modes/interactive/components/tool-group.d.ts

@@ -7,6 +7,7 @@ export declare class ToolGroupComponent implements Component {
     private pathOrigin;
     private reusesLeadingGap;
     private settled;
+    private cachedRender?;
     constructor(outputPad?: number, pathOrigin?: DiffexPathOrigin, options?: {
         reuseLeadingGap?: boolean;
     });

package/dist/modes/interactive/components/tool-group.js

@@ -7,6 +7,7 @@ export class ToolGroupComponent {
     pathOrigin;
     reusesLeadingGap;
     settled = false;
+    cachedRender;
     constructor(outputPad = 1, pathOrigin = "standalone", options = {}) {
         this.outputPad = outputPad;
         this.pathOrigin = pathOrigin;
@@ -18,13 +19,17 @@ export class ToolGroupComponent {
             return existing;
         }
         this.tools.set(toolCallId, component);
+        this.cachedRender = undefined;
         return component;
     }
     getTool(toolCallId) {
         return this.tools.get(toolCallId);
     }
     removeTool(toolCallId) {
-        return this.tools.delete(toolCallId);
+        const removed = this.tools.delete(toolCallId);
+        if (removed)
+            this.cachedRender = undefined;
+        return removed;
     }
     replaceTools(tools) {
         this.tools.clear();
@@ -32,6 +37,7 @@ export class ToolGroupComponent {
             this.tools.delete(toolCallId);
             this.tools.set(toolCallId, component);
         }
+        this.cachedRender = undefined;
     }
     hasTools() {
         return this.tools.size > 0;
@@ -42,34 +48,43 @@ export class ToolGroupComponent {
     setPathOrigin(pathOrigin, options = {}) {
         this.pathOrigin = pathOrigin;
         this.reusesLeadingGap = pathOrigin === "standalone" && options.reuseLeadingGap === true;
+        this.cachedRender = undefined;
     }
     markSettled() {
         this.settled = true;
+        this.cachedRender = undefined;
     }
     setOutputPad(padding) {
         this.outputPad = padding;
+        this.cachedRender = undefined;
     }
     setExpanded(expanded) {
         for (const tool of this.tools.values()) {
             tool.setExpanded(expanded);
         }
+        this.cachedRender = undefined;
     }
     setShowImages(show) {
         for (const tool of this.tools.values()) {
             tool.setShowImages(show);
         }
+        this.cachedRender = undefined;
     }
     setImageWidthCells(width) {
         for (const tool of this.tools.values()) {
             tool.setImageWidthCells(width);
         }
+        this.cachedRender = undefined;
     }
     invalidate() {
         for (const tool of this.tools.values()) {
             tool.invalidate();
         }
+        this.cachedRender = undefined;
     }
     render(width) {
+        if (this.settled && this.cachedRender?.width === width)
+            return this.cachedRender.lines;
         const safeWidth = Math.max(1, width);
         const outputPad = Math.min(Math.max(0, this.outputPad), Math.max(0, safeWidth - 1));
         const outerRailWidth = safeWidth - outputPad > 1 ? 1 : 0;
@@ -87,12 +102,14 @@ export class ToolGroupComponent {
             }
         }
         if (renderedTools.length === 0) {
-            if (this.pathOrigin !== "continued") {
-                return [];
-            }
-            return this.settled
-                ? new DiffexPathTerminus(outputPad).render(safeWidth)
-                : new DiffexPathRail(outputPad).render(safeWidth);
+            const lines = this.pathOrigin !== "continued"
+                ? []
+                : this.settled
+                    ? new DiffexPathTerminus(outputPad).render(safeWidth)
+                    : new DiffexPathRail(outputPad).render(safeWidth);
+            if (this.settled)
+                this.cachedRender = { width, lines };
+            return lines;
         }
         const label = this.settled ? "Explored" : "Exploring";
         const continuesPath = this.pathOrigin === "continued";
@@ -118,6 +135,8 @@ export class ToolGroupComponent {
                 result.push(visibleWidth(decoratedLine) > safeWidth ? truncateToWidth(decoratedLine, safeWidth, "") : decoratedLine);
             }
         }
+        if (this.settled)
+            this.cachedRender = { width, lines: result };
         return result;
     }
 }

package/dist/node_modules/@diffexai/diffex-agent-core/dist/agent-loop.js

@@ -460,11 +460,29 @@ async function failToolCallsFromTruncatedMessage(toolCalls, config, signal, emit
  */
 async function executeToolCalls(currentContext, assistantMessage, config, signal, emit) {
     const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
-    const hasSequentialToolCall = toolCalls.some((tc) => currentContext.tools?.find((t) => t.name === tc.name)?.executionMode === "sequential");
-    if (config.toolExecution === "sequential" || hasSequentialToolCall) {
+    if (config.toolExecution === "sequential") {
         return executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit);
     }
-    return executeToolCallsParallel(currentContext, assistantMessage, toolCalls, config, signal, emit);
+    const messages = [];
+    let terminate = true;
+    for (let index = 0; index < toolCalls.length;) {
+        if (signal?.aborted)
+            break;
+        const sequential = currentContext.tools?.find((tool) => tool.name === toolCalls[index].name)?.executionMode === "sequential";
+        let end = index + 1;
+        if (!sequential) {
+            while (end < toolCalls.length &&
+                currentContext.tools?.find((tool) => tool.name === toolCalls[end].name)?.executionMode !== "sequential") {
+                end++;
+            }
+        }
+        const executePhase = sequential ? executeToolCallsSequential : executeToolCallsParallel;
+        const phase = await executePhase(currentContext, assistantMessage, toolCalls.slice(index, end), config, signal, emit);
+        messages.push(...phase.messages);
+        terminate = terminate && phase.terminate;
+        index = end;
+    }
+    return { messages, terminate: messages.length > 0 && terminate };
 }
 async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
     const finalizedCalls = [];

package/dist/node_modules/@diffexai/diffex-agent-core/dist/types.d.ts

@@ -16,9 +16,11 @@ export type StreamFn = (model: Model<Api>, context: Context, options?: SimpleStr
  * Configuration for how tool calls from a single assistant message are executed.
  *
  * - "sequential": each tool call is prepared, executed, and finalized before the next one starts.
- * - "parallel": tool calls are prepared sequentially, then allowed tools execute concurrently.
- *   `tool_execution_end` is emitted in tool completion order after each tool is finalized,
- *   while tool-result message artifacts are emitted later in assistant source order.
+ * - "parallel": consecutive parallel-capable calls form groups separated by individual
+ *   tools declaring `executionMode: "sequential"`. Each group is prepared sequentially,
+ *   then allowed tools execute concurrently. Completion events follow finalization order;
+ *   tool-result message events follow assistant source order within each phase.
+ *   Hooks and awaited events settle before the next phase is prepared.
  */
 export type ToolExecutionMode = "sequential" | "parallel";
 /**
@@ -237,9 +239,9 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
     /**
      * Tool execution mode.
      * - "sequential": execute tool calls one by one
-     * - "parallel": preflight tool calls sequentially, then execute allowed tools concurrently;
-     *   emit `tool_execution_end` in tool completion order after each tool is finalized,
-     *   then emit tool-result message artifacts later in assistant source order
+     * - "parallel": execute consecutive parallel-capable calls concurrently, separated by
+     *   sequential tool barriers. Preflight each phase sequentially and await execution,
+     *   result hooks, completion events, and source-ordered result events before the next phase.
      *
      * Default: "parallel"
      */
@@ -250,6 +252,8 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      * Return `{ block: true }` to prevent execution. The loop emits an error tool result instead.
      * A blocked result can also set `terminate: true` to participate in the batch early-termination rule.
      * The hook receives the agent abort signal and is responsible for honoring it.
+     * In parallel mode, preflight runs sequentially within the current phase, after all
+     * prior phases have settled. Sibling results within that phase are not yet available.
      */
     beforeToolCall?: (context: BeforeToolCallContext, signal?: AbortSignal) => Promise<BeforeToolCallResult | undefined>;
     /**
@@ -264,6 +268,8 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
      *
      * Any omitted fields keep their original values. No deep merge is performed.
      * The hook receives the agent abort signal and is responsible for honoring it.
+     * Parallel siblings can finalize concurrently. All hooks and awaited result events
+     * in the current phase settle before preflight begins for the next phase.
      */
     afterToolCall?: (context: AfterToolCallContext, signal?: AbortSignal) => Promise<AfterToolCallResult | undefined>;
 }
@@ -362,11 +368,12 @@ export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any
     /** Execute the tool call. Throw on failure instead of encoding errors in `content`. */
     execute: (toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails>) => Promise<AgentToolResult<TDetails>>;
     /**
-     * Per-tool execution mode override.
-     * - "sequential": this tool must execute one at a time with other tool calls.
-     * - "parallel": this tool can execute concurrently with other tool calls.
+     * Per-tool scheduling metadata under global parallel execution.
+     * - "sequential": this call is an exclusive barrier in assistant source order.
+     * - "parallel": this call can execute concurrently within its consecutive group.
      *
-     * If omitted, the default execution mode applies.
+     * Omitted metadata is parallel-capable. Global sequential execution always runs
+     * calls one by one, including tools explicitly declaring "parallel".
      */
     executionMode?: ToolExecutionMode;
 }

package/dist/node_modules/@diffexai/diffex-agent-core/distribution-components.json

@@ -1,8 +1,8 @@
 [
   {
     "name": "@diffexai/diffex-agent-core",
-    "version": "0.3.1",
-    "sourceCommit": "9d59a28db4888b6824740505f0a16146667f036b",
+    "version": "0.3.2",
+    "sourceCommit": "57dbba8a810d2e4cc81e48a30a4f5736e0e2d5bf",
     "license": "Apache-2.0",
     "portions": "Diffex contributions; Pi-derived portions retain MIT terms in LICENSE",
     "notice": "LICENSE",
@@ -10,12 +10,12 @@
   },
   {
     "name": "@diffexai/diffex-ai",
-    "version": "^0.3.1",
+    "version": "^0.3.2",
     "distribution": "resolved separately by package manager; not bundled in this npm tarball"
   },
   {
     "name": "@diffexai/diffex-telemetry",
-    "version": "^0.3.1",
+    "version": "^0.3.2",
     "distribution": "resolved separately by package manager; not bundled in this npm tarball"
   },
   {

package/dist/node_modules/@diffexai/diffex-agent-core/distribution-files.json

@@ -1,5 +1,5 @@
 {
-  "sourceCommit": "9d59a28db4888b6824740505f0a16146667f036b",
+  "sourceCommit": "57dbba8a810d2e4cc81e48a30a4f5736e0e2d5bf",
   "algorithm": "sha256",
   "files": [
     {
@@ -8,7 +8,7 @@
     },
     {
       "path": "dist/agent-loop.js",
-      "sha256": "f9aeefb27c0391e02e3e39de475943b382afe83d948487597595faa8b3889a4d"
+      "sha256": "b1b846af2909c11fecd35a06cad1dd79c57a8c2ea8ea7240136d71169b4ecfa8"
     },
     {
       "path": "dist/agent.d.ts",
@@ -380,7 +380,7 @@
     },
     {
       "path": "dist/types.d.ts",
-      "sha256": "076d88249087ecd918b2111dfa97ea485ac7f2874930f836fa05a9c28f45141a"
+      "sha256": "f64317c4ce1d3ccb8284e6eed635b5540f9a27dfbea94ce709eeed18b4625b28"
     },
     {
       "path": "dist/types.js",

package/dist/node_modules/@diffexai/diffex-agent-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diffexai/diffex-agent-core",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "General-purpose agent with transport abstraction, state management, and attachment support",
   "type": "module",
   "main": "./dist/index.js",

package/dist/node_modules/@diffexai/diffex-ai/dist/providers/data/.manifest.json

@@ -1 +1 @@
-{"schemaVersion":3,"generatedAt":"2026-09-20T21:05:14.234Z","structureHash":"5ae57f6cf495fb2f4ede669bf128fd21195cd00e1fbb2c1e884764da807da5d2","files":{"amazon-bedrock.json":"9d3eed9613b9b56f0c5f202a61b279a7168edf01bae6c3218a7ab28664ff80ea","ant-ling.json":"4979fe79d99ed97382d7ce40170c6132e932e77906de1eb54464c042e7d63633","anthropic.json":"6937a397c6c7cf654990d072734efad023b652b294b04961d43a5835d7d08156","azure-openai-responses.json":"787ba62322c46fbc69bc1fcb7c7cfc100b8f74211c72adf9766b6dbf5eae0c41","baseten.json":"c7cf9a7e7e6bee9c53005acf4706c25f954adaa64a9058535fb7e5b1d6920852","cerebras.json":"9eaa554e1b02f3665f8f63e6432d253bf81351af7c72001054dd8108aa528a52","cloudflare-ai-gateway.json":"356a2892803067a5d042c5abb87051edba46f7209589c625f8bcea8c7c5ce5c9","cloudflare-workers-ai.json":"07ef63208ff7517fd1a80962f18143e21de399640423329490b157f459ccf995","deepseek.json":"0dcc807a4e5827b488c6ceac87884ff6e735e01cf4f2ddfec9dd812e6fde041b","fireworks.json":"4c9055f7a2c5345b808bb561b07b227fc29148e0fb774c0ac50db2b34ab89aaf","github-copilot.json":"37cfc1da3a6814e37e14c565ed0a1e41f2eb513b10aa8f11ac18f27fa392308c","google-vertex.json":"e1631109172dc1f7d7977570420a5bb86258bdd1088427e244a2c51545c4f24d","google.json":"7619bf03edd2a7acb06a2274a14b13c3a61354288abe029a758401d4de36a8fd","groq.json":"e4728fd72e358cd8f25e9a518e9b49a521ef44523d3debe38a7db9e0663c4077","huggingface.json":"a488b6f175b382277ccf7d487f877ef0c698994576bb55d2410838bf9c8c7c41","kimi-coding.json":"9da7ea8e9eb8df5d8f73acc25d3da5b41164f522c0f09b45265b4bf104743ac1","minimax-cn.json":"65d37e55a6d9585855f94b3fb7739308d107fe248ebd9e1001d1c5d4606ad2c4","minimax.json":"c7dc5765995ae77242916430929c7cc9a782589f7e483e13f7e01663190d028e","mistral.json":"be522597b22bceeb0bb9a0ba1781647649ffd19637d0c8e67b056d7b0ec33d52","moonshotai-cn.json":"63f77de8782dce6a8d4649b6075ee04c9732863ae85561e0867871220c558bde","moonshotai.json":"2a8dfb97eb905e991c22081dc09bd4a61c05b7fa9ac0d5c72d6930f601f490f1","nvidia.json":"2ff6862206269af88a694e627c4b54753055357710adaf49ac8518d102c17407","openai-codex.json":"4a73818291987693fcb53e9e61b4be3429ffd78b3f64ea877a34c5f9928c89e1","openai.json":"6fa1954abd6c5b301620a02a57412bd60bbfdf20465b9a3eb4d113f88dfb8f7b","opencode-go.json":"fa6d6737da943fbb9c36487cb4cd5bc152d1f2fd548280bbe9d35d0304e79f11","opencode.json":"43c5d9cc6fab109411e6ac8eebac4b9fb0b00cff844cf0eb6c1559a08586525f","openrouter.json":"a3375b66ad7b4bb61f22d867e132c991d3b9851436c529838c109b9794d59b93","qwen-token-plan-cn.json":"a50420854a624ea82155d9621cd88d6cbd7802498d28fb1fd317eb7a1bc26cc7","qwen-token-plan-individual.json":"0e1578a5c0e11d65644bb42d1d6efee5af97a55a4881d0421ab68bd970d4d4ef","qwen-token-plan.json":"24285f68b2350aa1d98ecaeafe0914bce97940fe8798eff20f2a5c6d8c26bd6f","together.json":"927c707d06f2236cdab13f14c870fb58bce0614ba7287bbcd57cc9fd66d191ed","vercel-ai-gateway.json":"03b0830a794af1bc921fb504565534bedec660fcc9482adcf56ec5fb27703e60","xai.json":"282838b0546d63106c81f1703cdf5ed31ebfe0c5f13a4bec0d590472cbbe03f2","xiaomi-token-plan-ams.json":"7ce8ed244672c45737d286ff3ca9c3a2686a5d4b2f0c5f71ab9348c14b14daf3","xiaomi-token-plan-cn.json":"684892b5fe6fa371d6040d2011c0fa33facd650d2eaf19f5dbee8efb33016200","xiaomi-token-plan-sgp.json":"b19e79b82ac4fdcb080e6d220106797504c885ed70b27fc2b3c1aa4810f32963","xiaomi.json":"810368d3828c8bb9498012a0d48639030c0c216b8c13e79da02daa515aa23448","zai-coding-cn.json":"abf4cbc22507b9d545842072b5e34bce230025fc20f7b1cc67db3782c1dc4b56","zai.json":"089af736a622b0a25e417493819f4e174884afba43235c5a1f17814057875627"}}
+{"schemaVersion":3,"generatedAt":"2026-09-29T21:05:24.416Z","structureHash":"2fd45211a507dbf73974cbe675b576aeb2dfae490b569af9b3b90f9f601d7be5","files":{"amazon-bedrock.json":"1e0b4308b61f51c642616571d53efcca4aada249b20d220ca9068df7e5ea52fd","ant-ling.json":"4979fe79d99ed97382d7ce40170c6132e932e77906de1eb54464c042e7d63633","anthropic.json":"b2976a77dd2a3260d401918df7c523bd2124abae2382f7a67229829e2701d899","azure-openai-responses.json":"dfcc219adb7d04783861274cb94ac503b9a0d9f00a4e77c3637ebfc779ee5eb8","baseten.json":"c7cf9a7e7e6bee9c53005acf4706c25f954adaa64a9058535fb7e5b1d6920852","cerebras.json":"3be228c613905c215c9da3d0b3535e10cc594ff2351b05390744c7c34de89b6c","cloudflare-ai-gateway.json":"fac11bff507133190fcb7cb216656a8ad1b8d3b8c37c1b523a6d85f931b0cbda","cloudflare-workers-ai.json":"6012eb769382a5a9fa96ec5f429f6744848e377327c9063573a15006ef0652ce","deepseek.json":"0dcc807a4e5827b488c6ceac87884ff6e735e01cf4f2ddfec9dd812e6fde041b","fireworks.json":"f3e423850d1509690c0d8cfd4071bdb822f01a05e6d691032c309476edc8a927","github-copilot.json":"418a6da7c705b9043ffecc21597cb7d79bf80b6fb117f95a5a7675b68a032539","google-vertex.json":"97d80ac909d256cc1bf19ac54d9d8131c492e7c0c102ad89f68ade528544e0ad","google.json":"68f6cf6283cc0d69b77b0fa79e9c94774e96524f61ebba616319f05d5c9db56c","groq.json":"e4728fd72e358cd8f25e9a518e9b49a521ef44523d3debe38a7db9e0663c4077","huggingface.json":"2f93082144a7b2a1cbf79148244ce7559e0428d6310c5eb0648bca89b15a8b4b","kimi-coding.json":"9da7ea8e9eb8df5d8f73acc25d3da5b41164f522c0f09b45265b4bf104743ac1","minimax-cn.json":"4f636b47b28a507ad33b5eaba33fc4889e5956504d10f2a0d9c61167ae01ff1d","minimax.json":"9fd1764ffeefebded8579039cf0c48854a43e4c5b724f62361fc2ac54f705aa1","mistral.json":"9da97430d9b86ad7f606b0fc088694e7a04c38bfa8963a33e1205b3141c917eb","moonshotai-cn.json":"c1d6024d0095bb34e33847a3281692e8ddb7ddbb61748a0373cdab45f414d264","moonshotai.json":"08b8a7bbb30aa3a5ed077f02bd59ea5e9d32a1a8257e56d1606be8d722091783","nvidia.json":"6493e09b5db8b8fe9c8fae5bc15dc287645f37f83a4ed3a1ad1181e5830b5ff7","openai-codex.json":"4a73818291987693fcb53e9e61b4be3429ffd78b3f64ea877a34c5f9928c89e1","openai.json":"d8107710ade17d9c177b677135bf1ae88d6b884ee765cd64b74afe501f1f0844","opencode-go.json":"af32bbce67a5b2f705c43cd47e301e9fd4548bd3af03daaebb4b63bca864f9bc","opencode.json":"b3b709db64eb71505560758e36d287458280ce3d361d0d87ab5d616d6d6cf8a3","openrouter.json":"21dbdf7e09616dd36bfbf2121801cee9b8f68b5462e69c009bf1f665a2ba4002","qwen-token-plan-cn.json":"a50420854a624ea82155d9621cd88d6cbd7802498d28fb1fd317eb7a1bc26cc7","qwen-token-plan-individual.json":"0e1578a5c0e11d65644bb42d1d6efee5af97a55a4881d0421ab68bd970d4d4ef","qwen-token-plan.json":"24285f68b2350aa1d98ecaeafe0914bce97940fe8798eff20f2a5c6d8c26bd6f","together.json":"b4971d293e5be6b9acaf7b5d9aa588e6374e5317c116e98437128197c39a2fac","vercel-ai-gateway.json":"79ffb1b0c83cec8d26472ddc519ad6184eeb9cb1c960fd02c7dbf1473dcc5871","xai.json":"d036f5d1ececd7280c09ca1a6249553f39a7a1087ddb129a0d689a427fc944c4","xiaomi-token-plan-ams.json":"9581074003df2c31dbe483221dbbd1891e92d05102fcb816d51cbb22542174cf","xiaomi-token-plan-cn.json":"df9f18cca62ed29398124b3c9f50b157eea83c32167579a40ac129a3a673e4d6","xiaomi-token-plan-sgp.json":"5681a7eed774bc4b4e296cdae1a5028176b856b48af96cbd7776a03ba905aab1","xiaomi.json":"506eef7c189328cabce83768a48ec3e59c3f8a575f840d8ffcefa6966c340562","zai-coding-cn.json":"abf4cbc22507b9d545842072b5e34bce230025fc20f7b1cc67db3782c1dc4b56","zai.json":"089af736a622b0a25e417493819f4e174884afba43235c5a1f17814057875627"}}