veryfront 0.1.700 → 0.1.703

package/esm/src/agent/streaming/fork-runtime-stream.js

@@ -1,12 +1,13 @@
 import * as dntShim from "../../../_dnt.shims.js";
 import { createToolsFromHostDefinitions, traceHostTools, } from "../../tool/index.js";
 import { isRecord } from "../../chat/conversation.js";
-import { safeJsonParse } from "../../chat/provider-errors.js";
 import { runWithVeryfrontCloudContextAsync } from "../../provider/veryfront-cloud/context.js";
-import { mergeToolInputDelta, parseToolInputObject, streamDataStreamEvents, stripLeadingEmptyObjectPlaceholder, } from "./data-stream.js";
+import { mergeToolInputDelta, parseToolInputObject, streamDataStreamEvents, } from "./data-stream.js";
+import { buildRecoveredStepParts, createForkRuntimeStreamMappingState, getParsedStreamedToolInput, mapAgUiRuntimeEventToForkParts, } from "./fork-runtime-part-mapper.js";
 import { HOSTED_CHILD_STREAM_TIMEOUT_TOKEN, resolveHostedChildPromiseWithTimeout, } from "../hosted/child-stream-watchdog.js";
 import { getForkRuntimeAllowedToolNames, getProviderNativeToolNames, } from "../runtime/provider-native-tool-inventory.js";
 import { AgentRuntime } from "../runtime/index.js";
+export { buildRecoveredStepParts, createForkRuntimeStreamMappingState, createFrameworkStreamState, mapAgUiRuntimeEventToForkParts, mapFrameworkEventToForkParts, } from "./fork-runtime-part-mapper.js";
 /** Default value for fork response promise timeout ms. */
 export const DEFAULT_FORK_RESPONSE_PROMISE_TIMEOUT_MS = 1_000;
 /** Starts agent runtime fork with host tools. */
@@ -547,246 +548,3 @@ export async function resolveForkStepResponse(input) {
         state: fallbackState,
     });
 }
-function warnForkRuntimeStream(logger, message, metadata) {
-    logger?.warn(message, metadata);
-}
-/** Builds recovered step parts. */
-export function buildRecoveredStepParts(step, state) {
-    const recoveredParts = [];
-    for (const toolCall of step.toolCalls) {
-        if (state.emittedToolCallIds.has(toolCall.toolCallId)) {
-            continue;
-        }
-        const streamedCall = state.toolCalls.get(toolCall.toolCallId);
-        warnForkRuntimeStream(state.logger, "Child fork recovered missing tool-call from final step", {
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            sawInputStart: streamedCall?.sawInputStart ?? false,
-            sawInputDelta: streamedCall?.sawInputDelta ?? false,
-            sawInputAvailable: streamedCall?.sawInputAvailable ?? false,
-            sawOutputAvailable: streamedCall?.sawOutputAvailable ?? false,
-            sawOutputError: streamedCall?.sawOutputError ?? false,
-        });
-        state.emittedToolCallIds.add(toolCall.toolCallId);
-        recoveredParts.push({
-            type: "tool-call",
-            toolCallId: toolCall.toolCallId,
-            toolName: toolCall.toolName,
-            input: toolCall.input,
-        });
-    }
-    for (const toolResult of step.toolResults) {
-        if (state.emittedToolResultIds.has(toolResult.toolCallId)) {
-            continue;
-        }
-        const streamedCall = state.toolCalls.get(toolResult.toolCallId);
-        warnForkRuntimeStream(state.logger, "Child fork recovered missing tool-result from final step", {
-            toolCallId: toolResult.toolCallId,
-            toolName: toolResult.toolName,
-            sawInputStart: streamedCall?.sawInputStart ?? false,
-            sawInputDelta: streamedCall?.sawInputDelta ?? false,
-            sawInputAvailable: streamedCall?.sawInputAvailable ?? false,
-            sawOutputAvailable: streamedCall?.sawOutputAvailable ?? false,
-            sawOutputError: streamedCall?.sawOutputError ?? false,
-        });
-        state.emittedToolResultIds.add(toolResult.toolCallId);
-        recoveredParts.push({
-            type: "tool-result",
-            toolCallId: toolResult.toolCallId,
-            toolName: toolResult.toolName,
-            input: toolResult.input,
-            output: toolResult.output,
-        });
-    }
-    return recoveredParts;
-}
-function isEmptyRecord(value) {
-    return Object.keys(value).length === 0;
-}
-function getParsedStreamedToolInput(inputText) {
-    const strippedInputText = stripLeadingEmptyObjectPlaceholder(inputText).trim();
-    const normalizedInputText = strippedInputText.startsWith('"')
-        ? `{${strippedInputText}`
-        : strippedInputText;
-    if (normalizedInputText.length === 0) {
-        return {};
-    }
-    const parsed = safeJsonParse(normalizedInputText);
-    if (!parsed.ok) {
-        return null;
-    }
-    return isRecord(parsed.value) ? Object.fromEntries(Object.entries(parsed.value)) : {};
-}
-function buildToolCallPartIfNeeded(toolCallId, state) {
-    const toolCall = state.toolCalls.get(toolCallId);
-    if (!toolCall || state.emittedToolCallIds.has(toolCallId)) {
-        return [];
-    }
-    state.emittedToolCallIds.add(toolCallId);
-    return [
-        {
-            type: "tool-call",
-            toolCallId,
-            toolName: toolCall.toolName,
-            input: toolCall.input,
-        },
-    ];
-}
-/** State for create fork runtime stream mapping. */
-export function createForkRuntimeStreamMappingState(input = {}) {
-    return {
-        toolCalls: new Map(),
-        emittedToolCallIds: new Set(),
-        emittedToolResultIds: new Set(),
-        ...(input.logger ? { logger: input.logger } : {}),
-    };
-}
-/** Map AG-UI runtime event to fork parts. */
-export function mapAgUiRuntimeEventToForkParts(event, state) {
-    switch (event.type) {
-        case "reasoning-delta":
-            return typeof event.delta === "string"
-                ? [{ type: "reasoning-delta", text: event.delta }]
-                : [];
-        case "text-delta":
-            return typeof event.delta === "string" ? [{ type: "text-delta", text: event.delta }] : [];
-        case "tool-input-start": {
-            const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
-            const toolName = typeof event.toolName === "string" ? event.toolName : null;
-            if (!toolCallId || !toolName) {
-                return [];
-            }
-            const existing = state.toolCalls.get(toolCallId);
-            state.toolCalls.set(toolCallId, {
-                toolName,
-                inputText: existing?.inputText ?? "",
-                input: existing?.input ?? {},
-                sawInputStart: true,
-                sawInputDelta: existing?.sawInputDelta ?? false,
-                sawInputAvailable: existing?.sawInputAvailable ?? false,
-                sawOutputAvailable: existing?.sawOutputAvailable ?? false,
-                sawOutputError: existing?.sawOutputError ?? false,
-            });
-            return [{ type: "tool-input-start", toolCallId, toolName }];
-        }
-        case "tool-input-delta": {
-            const inputToolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
-            const inputDelta = typeof event.inputTextDelta === "string" ? event.inputTextDelta : null;
-            if (!inputToolCallId || !inputDelta) {
-                return [];
-            }
-            const existing = state.toolCalls.get(inputToolCallId);
-            if (existing) {
-                existing.inputText = mergeToolInputDelta(existing.inputText, inputDelta);
-                existing.sawInputDelta = true;
-                const parsedInput = getParsedStreamedToolInput(existing.inputText);
-                if (parsedInput) {
-                    existing.input = parsedInput;
-                }
-            }
-            else {
-                warnForkRuntimeStream(state.logger, "Child fork received tool-input-delta before tool-input-start", {
-                    toolCallId: inputToolCallId,
-                    deltaLength: inputDelta.length,
-                });
-            }
-            return [{ type: "tool-input-delta", toolCallId: inputToolCallId, delta: inputDelta }];
-        }
-        case "tool-input-available": {
-            const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
-            const toolName = typeof event.toolName === "string" ? event.toolName : null;
-            if (!toolCallId || !toolName) {
-                return [];
-            }
-            const input = parseToolInputObject(event.input);
-            const existing = state.toolCalls.get(toolCallId);
-            const resolvedInput = existing && isEmptyRecord(input) && !isEmptyRecord(existing.input)
-                ? existing.input
-                : input;
-            state.toolCalls.set(toolCallId, {
-                toolName,
-                inputText: "",
-                input: resolvedInput,
-                sawInputStart: existing?.sawInputStart ?? false,
-                sawInputDelta: existing?.sawInputDelta ?? false,
-                sawInputAvailable: true,
-                sawOutputAvailable: existing?.sawOutputAvailable ?? false,
-                sawOutputError: existing?.sawOutputError ?? false,
-            });
-            return buildToolCallPartIfNeeded(toolCallId, state);
-        }
-        case "tool-output-available": {
-            if (event.preliminary === true) {
-                return [];
-            }
-            const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
-            if (!toolCallId) {
-                return [];
-            }
-            const call = state.toolCalls.get(toolCallId);
-            if (!call) {
-                return [];
-            }
-            call.sawOutputAvailable = true;
-            const parts = [
-                ...buildToolCallPartIfNeeded(toolCallId, state),
-            ];
-            state.emittedToolResultIds.add(toolCallId);
-            parts.push({
-                type: "tool-result",
-                toolCallId,
-                toolName: call.toolName,
-                input: call.input,
-                output: Object.hasOwn(event, "output") ? event.output : null,
-            });
-            return parts;
-        }
-        case "tool-output-error":
-        case "tool-input-error": {
-            const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : null;
-            if (!toolCallId) {
-                return [];
-            }
-            const call = state.toolCalls.get(toolCallId);
-            const errorText = typeof event.errorText === "string"
-                ? event.errorText
-                : typeof event.error === "string"
-                    ? event.error
-                    : "Tool execution failed";
-            if (call) {
-                call.sawOutputError = true;
-            }
-            const parts = [
-                ...buildToolCallPartIfNeeded(toolCallId, state),
-            ];
-            parts.push({
-                type: "tool-error",
-                toolCallId,
-                toolName: call?.toolName ?? "unknown",
-                input: call?.input ?? {},
-                error: new Error(errorText),
-            });
-            return parts;
-        }
-        case "error": {
-            const errorText = typeof event.errorText === "string"
-                ? event.errorText
-                : "Framework stream failed";
-            return [{ type: "error", error: new Error(errorText) }];
-        }
-        default:
-            return [];
-    }
-}
-/** State for create framework stream.
- * @deprecated Use createForkRuntimeStreamMappingState.
- */
-export function createFrameworkStreamState(input = {}) {
-    return createForkRuntimeStreamMappingState(input);
-}
-/** Handles map framework event to fork parts.
- * @deprecated Use mapAgUiRuntimeEventToForkParts.
- */
-export function mapFrameworkEventToForkParts(event, state) {
-    return mapAgUiRuntimeEventToForkParts(event, state);
-}

package/esm/src/integrations/_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_data.d.ts","sourceRoot":"","sources":["../../../src/src/integrations/_data.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,eAAO,MAAM,UAAU,EAAE,iBAAiB,EAs9XzC,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA+ExC,CAAC"}
+{"version":3,"file":"_data.d.ts","sourceRoot":"","sources":["../../../src/src/integrations/_data.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,eAAO,MAAM,UAAU,EAAE,iBAAiB,EA66XzC,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA+ExC,CAAC"}

package/esm/src/integrations/_data.js

@@ -2102,33 +2102,10 @@ export const connectors = [
                 "description": "Get the authenticated user's Figma profile (id, email, handle). Use this to verify the connection and identify the user.",
                 "requiresWrite": false,
                 "endpoint": { "method": "GET", "url": "https://api.figma.com/v1/me" },
-            }, {
-                "id": "list_files",
-                "name": "List Files",
-                "description": "List recent Figma files accessible to the user",
-                "requiresWrite": false,
-                "endpoint": {
-                    "method": "GET",
-                    "url": "https://api.figma.com/v1/projects/{projectId}/files",
-                    "params": {
-                        "projectId": {
-                            "type": "string",
-                            "in": "path",
-                            "description": "Figma project ID whose files should be listed",
-                            "required": true,
-                        },
-                        "branch_data": {
-                            "type": "boolean",
-                            "in": "query",
-                            "description": "Include branch metadata",
-                            "default": false,
-                        },
-                    },
-                },
             }, {
                 "id": "get_file",
                 "name": "Get File",
-                "description": "Get detailed information about a Figma file including components and styles",
+                "description": "Get detailed information about a Figma file, including pages, frames, components, and styles. Requires a Figma file key from a file or design URL.",
                 "requiresWrite": false,
                 "endpoint": {
                     "method": "GET",
@@ -2204,24 +2181,6 @@ export const connectors = [
                         },
                     },
                 },
-            }, {
-                "id": "list_projects",
-                "name": "List Projects",
-                "description": "List all projects in a team. The teamId is the numeric ID found in the Figma URL: figma.com/files/team/{teamId}/...",
-                "requiresWrite": false,
-                "endpoint": {
-                    "method": "GET",
-                    "url": "https://api.figma.com/v1/teams/{teamId}/projects",
-                    "params": {
-                        "teamId": {
-                            "type": "string",
-                            "in": "path",
-                            "description": "Numeric Figma team ID from the URL: figma.com/files/team/{teamId}/...",
-                            "required": true,
-                        },
-                    },
-                    "response": { "transform": "projects" },
-                },
             }],
         "prompts": [{
                 "id": "review_design",

package/esm/src/oauth/providers/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/src/oauth/providers/common.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAU1B,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,WAAW,EAAE,kBAqBzB,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAc1B,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,WAAW,EAAE,kBAUzB,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAU1B,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAU1B,CAAC;AAEF,sCAAsC;AACtC,eAAO,MAAM,cAAc,EAAE,kBAgB5B,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,kBAa3B,CAAC;AAEF,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,EAAE,kBAU9B,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,kBAW3B,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,WAAW,EAAE,kBAUzB,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAU1B,CAAC;AAEF,kCAAkC;AAClC,eAAO,MAAM,UAAU,EAAE,kBAWxB,CAAC;AAEF,sCAAsC;AACtC,eAAO,MAAM,cAAc,EAAE,kBAU5B,CAAC;AAEF,uCAAuC;AACvC,eAAO,MAAM,eAAe,EAAE,kBAU7B,CAAC;AAEF,uCAAuC;AACvC,eAAO,MAAM,eAAe,EAAE,kBAU7B,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,kBAU3B,CAAC;AAEF,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,EAAE,kBAU9B,CAAC;AAEF,kCAAkC;AAClC,eAAO,MAAM,UAAU,EAAE,kBAgBxB,CAAC;AAEF,iCAAiC;AACjC,eAAO,MAAM,SAAS,EAAE,kBAUvB,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,WAAW,EAAE,kBAUzB,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAa1B,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,kBAU3B,CAAC;AAEF,uCAAuC;AACvC,eAAO,MAAM,eAAe,EAAE,kBAU7B,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBb,CAAC;AAEX,eAAO,MAAM,cAAc,EAEtB,OAAO,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../src/src/oauth/providers/common.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAU1B,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,WAAW,EAAE,kBAqBzB,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAc1B,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,WAAW,EAAE,kBAezB,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAU1B,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAU1B,CAAC;AAEF,sCAAsC;AACtC,eAAO,MAAM,cAAc,EAAE,kBAgB5B,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,kBAa3B,CAAC;AAEF,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,EAAE,kBAU9B,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,kBAW3B,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,WAAW,EAAE,kBAUzB,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAU1B,CAAC;AAEF,kCAAkC;AAClC,eAAO,MAAM,UAAU,EAAE,kBAWxB,CAAC;AAEF,sCAAsC;AACtC,eAAO,MAAM,cAAc,EAAE,kBAU5B,CAAC;AAEF,uCAAuC;AACvC,eAAO,MAAM,eAAe,EAAE,kBAU7B,CAAC;AAEF,uCAAuC;AACvC,eAAO,MAAM,eAAe,EAAE,kBAU7B,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,kBAU3B,CAAC;AAEF,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,EAAE,kBAU9B,CAAC;AAEF,kCAAkC;AAClC,eAAO,MAAM,UAAU,EAAE,kBAgBxB,CAAC;AAEF,iCAAiC;AACjC,eAAO,MAAM,SAAS,EAAE,kBAUvB,CAAC;AAEF,mCAAmC;AACnC,eAAO,MAAM,WAAW,EAAE,kBAUzB,CAAC;AAEF,oCAAoC;AACpC,eAAO,MAAM,YAAY,EAAE,kBAa1B,CAAC;AAEF,qCAAqC;AACrC,eAAO,MAAM,aAAa,EAAE,kBAU3B,CAAC;AAEF,uCAAuC;AACvC,eAAO,MAAM,eAAe,EAAE,kBAU7B,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBb,CAAC;AAEX,eAAO,MAAM,cAAc,EAEtB,OAAO,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/esm/src/oauth/providers/common.js

@@ -60,7 +60,12 @@ export const figmaConfig = {
     clientIdEnvVar: "FIGMA_CLIENT_ID",
     clientSecretEnvVar: "FIGMA_CLIENT_SECRET",
     apiBaseUrl: "https://api.figma.com/v1",
-    defaultScopes: ["file_read"],
+    defaultScopes: [
+        "current_user:read",
+        "file_content:read",
+        "file_comments:read",
+        "file_comments:write",
+    ],
 };
 /** Configuration used by linear. */
 export const linearConfig = {

package/esm/src/utils/version-constant.d.ts

@@ -1,3 +1,3 @@
 /** Shared version value. */
-export declare const VERSION = "0.1.700";
+export declare const VERSION = "0.1.703";
 //# sourceMappingURL=version-constant.d.ts.map

package/esm/src/utils/version-constant.js

@@ -1,4 +1,4 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
 /** Shared version value. */
-export const VERSION = "0.1.700";
+export const VERSION = "0.1.703";

package/esm/src/workflow/claude-code/react/event-state-reducer.d.ts

@@ -0,0 +1,37 @@
+import type { ClaudeCodeEvent, ClaudeCodeEventExtended, ClaudeCodeResult } from "../types.js";
+export interface ClaudeCodeCurrentTool {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export interface ClaudeCodeToolCall extends ClaudeCodeCurrentTool {
+    output?: string;
+    isError?: boolean;
+}
+export interface ClaudeCodeAllToolCall extends ClaudeCodeToolCall {
+    iteration: number;
+}
+export interface ClaudeCodeEventState {
+    isRunning: boolean;
+    currentIteration: number;
+    maxIterations: number;
+    text: string;
+    currentTool: ClaudeCodeCurrentTool | null;
+    toolCalls: ClaudeCodeToolCall[];
+    result: ClaudeCodeResult | null;
+    error: string | null;
+}
+export interface ClaudeCodeEventReducerOptions {
+    keepEventHistory?: boolean;
+    maxEventHistory?: number;
+    trackAllToolCalls?: boolean;
+}
+type ClaudeCodeEventStateWithOptionalTracking = ClaudeCodeEventState & {
+    events?: ClaudeCodeEvent[];
+    allToolCalls?: ClaudeCodeAllToolCall[];
+};
+export declare function createClaudeCodeEventState(): ClaudeCodeEventState;
+export declare function isClaudeCodeCoreEvent(event: ClaudeCodeEventExtended): event is ClaudeCodeEvent;
+export declare function reduceClaudeCodeEventState<TState extends ClaudeCodeEventStateWithOptionalTracking>(previous: TState, event: ClaudeCodeEvent, options?: ClaudeCodeEventReducerOptions): TState;
+export {};
+//# sourceMappingURL=event-state-reducer.d.ts.map

package/esm/src/workflow/claude-code/react/event-state-reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-state-reducer.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/claude-code/react/event-state-reducer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE9F,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,kBAAmB,SAAQ,qBAAqB;IAC/D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB;IAC/D,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC1C,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAChC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,6BAA6B;IAC5C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,KAAK,wCAAwC,GAAG,oBAAoB,GAAG;IACrE,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,qBAAqB,EAAE,CAAC;CACxC,CAAC;AAkBF,wBAAgB,0BAA0B,IAAI,oBAAoB,CAWjE;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,uBAAuB,GAC7B,KAAK,IAAI,eAAe,CAE1B;AAED,wBAAgB,0BAA0B,CACxC,MAAM,SAAS,wCAAwC,EAEvD,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,eAAe,EACtB,OAAO,GAAE,6BAAkC,GAC1C,MAAM,CA2FR"}

package/esm/src/workflow/claude-code/react/event-state-reducer.js

@@ -0,0 +1,104 @@
+const CLAUDE_CODE_CORE_EVENT_TYPES = new Set([
+    "iteration_start",
+    "text_delta",
+    "text_complete",
+    "tool_call_start",
+    "tool_call_input",
+    "tool_call_complete",
+    "tool_result",
+    "iteration_complete",
+    "thinking_start",
+    "thinking_delta",
+    "thinking_complete",
+    "complete",
+    "error",
+]);
+export function createClaudeCodeEventState() {
+    return {
+        isRunning: false,
+        currentIteration: 0,
+        maxIterations: 20,
+        text: "",
+        currentTool: null,
+        toolCalls: [],
+        result: null,
+        error: null,
+    };
+}
+export function isClaudeCodeCoreEvent(event) {
+    return CLAUDE_CODE_CORE_EVENT_TYPES.has(event.type);
+}
+export function reduceClaudeCodeEventState(previous, event, options = {}) {
+    const next = { ...previous };
+    if (options.keepEventHistory && Array.isArray(next.events)) {
+        next.events = [...(previous.events ?? []), event].slice(-(options.maxEventHistory ?? 100));
+    }
+    switch (event.type) {
+        case "iteration_start":
+            next.isRunning = true;
+            next.currentIteration = event.iteration;
+            next.maxIterations = event.maxIterations;
+            next.toolCalls = [];
+            next.currentTool = null;
+            break;
+        case "text_delta":
+            next.text = previous.text + event.content;
+            break;
+        case "text_complete":
+            next.text = event.content;
+            break;
+        case "tool_call_start":
+            next.currentTool = {
+                id: event.toolCallId,
+                name: event.toolName,
+                input: {},
+            };
+            break;
+        case "tool_call_complete":
+            next.currentTool = null;
+            next.toolCalls = [
+                ...previous.toolCalls,
+                {
+                    id: event.toolCallId,
+                    name: event.toolName,
+                    input: event.input,
+                },
+            ];
+            break;
+        case "tool_result": {
+            next.toolCalls = previous.toolCalls.map((toolCall) => toolCall.id === event.toolCallId
+                ? { ...toolCall, output: event.output, isError: event.isError }
+                : toolCall);
+            if (options.trackAllToolCalls && Array.isArray(next.allToolCalls)) {
+                const matchingToolCall = previous.toolCalls.find((toolCall) => toolCall.id === event.toolCallId);
+                next.allToolCalls = [
+                    ...(previous.allToolCalls ?? []),
+                    {
+                        iteration: event.iteration ?? previous.currentIteration,
+                        id: event.toolCallId,
+                        name: event.toolName,
+                        input: matchingToolCall?.input ?? {},
+                        output: event.output,
+                        isError: event.isError,
+                    },
+                ];
+            }
+            break;
+        }
+        case "iteration_complete":
+            next.currentTool = null;
+            break;
+        case "complete":
+            next.isRunning = false;
+            next.result = event.result;
+            next.currentTool = null;
+            break;
+        case "error":
+            next.error = event.message;
+            if (!event.recoverable) {
+                next.isRunning = false;
+            }
+            break;
+    }
+    return next;
+}

package/esm/src/workflow/claude-code/react/use-claude-code-stream.d.ts

@@ -1,45 +1,13 @@
 import type { ClaudeCodeEvent, ClaudeCodeResult } from "../types.js";
+import { type ClaudeCodeAllToolCall, type ClaudeCodeEventState } from "./event-state-reducer.js";
 /**
  * State for Claude Code streaming
  */
-export interface UseClaudeCodeStreamState {
+export interface UseClaudeCodeStreamState extends ClaudeCodeEventState {
     /** Whether currently connected to stream */
     isConnected: boolean;
-    /** Whether agent is currently executing */
-    isRunning: boolean;
-    /** Current iteration number */
-    currentIteration: number;
-    /** Maximum iterations allowed */
-    maxIterations: number;
-    /** Accumulated text output */
-    text: string;
-    /** Current tool being executed (if any) */
-    currentTool: {
-        id: string;
-        name: string;
-        input: Record<string, unknown>;
-    } | null;
-    /** Tool calls in current iteration */
-    toolCalls: Array<{
-        id: string;
-        name: string;
-        input: Record<string, unknown>;
-        output?: string;
-        isError?: boolean;
-    }>;
     /** All tool calls across all iterations */
-    allToolCalls: Array<{
-        iteration: number;
-        id: string;
-        name: string;
-        input: Record<string, unknown>;
-        output?: string;
-        isError?: boolean;
-    }>;
-    /** Final result (when complete) */
-    result: ClaudeCodeResult | null;
-    /** Error message (if any) */
-    error: string | null;
+    allToolCalls: ClaudeCodeAllToolCall[];
     /** Raw events (for debugging) */
     events: ClaudeCodeEvent[];
 }

package/esm/src/workflow/claude-code/react/use-claude-code-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-claude-code-stream.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/claude-code/react/use-claude-code-stream.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"use-claude-code-stream.d.ts","sourceRoot":"","sources":["../../../../../src/src/workflow/claude-code/react/use-claude-code-stream.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EAG1B,MAAM,0BAA0B,CAAC;AASlC;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE,4CAA4C;IAC5C,WAAW,EAAE,OAAO,CAAC;IAErB,2CAA2C;IAC3C,YAAY,EAAE,qBAAqB,EAAE,CAAC;IAEtC,iCAAiC;IACjC,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;IAEZ,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IAEd,4BAA4B;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,8BAA8B;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,6BAA6B;IAC7B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,yBAAyB;IACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,oCAAoC;IACpC,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,gBAAgB;IAChB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAC3C,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,0BAA0B,GAClC,wBAAwB,GAAG;IAC5B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB,CAoIA;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,IAAI,CAAC,0BAA0B,EAAE,kBAAkB,GAAG,iBAAiB,CAAC,GAChF;IACD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAGA"}