veryfront 0.1.1136 → 0.1.1143

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "veryfront",
-    "version": "0.1.1136",
+    "version": "0.1.1143",
     "license": "Apache-2.0",
     "nodeModulesDir": "auto",
     "minimumDependencyAge": {
@@ -406,14 +406,14 @@ export default {
         "build": "deno task build:prepare && deno run -A scripts/build/compile-binary.ts --output ./bin/veryfront",
         "build:npm": "deno run -A scripts/build/generate-integrations-module.ts && deno task generate && deno run -A scripts/build/build-npm-dnt.ts",
         "release": "deno run -A scripts/release.ts",
-        "test": "deno task generate && VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --allow-all '--ignore=tests/e2e,tests/integration/compiled-binary-e2e.test.ts' --unstable-worker-options --unstable-net",
-        "test:unit": "deno task generate && VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --allow-all --v8-flags=--max-old-space-size=8192 '--ignore=tests,src/workflow/__tests__' --unstable-worker-options --unstable-net $(find src cli -name '*.test.ts*' ! -name '*.integration.test.ts*')",
-        "test:integration": "deno task generate && VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --allow-all '--ignore=tests/e2e,tests/integration/compiled-binary-e2e.test.ts' tests --unstable-worker-options --unstable-net",
-        "test:integration:cli": "VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --no-check --parallel --allow-all --unstable-worker-options --unstable-net $(find cli -name '*.integration.test.ts')",
+        "test": "deno task generate && DENO_TESTING=1 VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --allow-all '--ignore=tests/e2e,tests/integration/compiled-binary-e2e.test.ts' --unstable-worker-options --unstable-net",
+        "test:unit": "deno task generate && DENO_TESTING=1 VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --allow-all --v8-flags=--max-old-space-size=8192 '--ignore=tests,src/workflow/__tests__' --unstable-worker-options --unstable-net $(find src cli -name '*.test.ts*' ! -name '*.integration.test.ts*')",
+        "test:integration": "deno task generate && DENO_TESTING=1 VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --allow-all '--ignore=tests/e2e,tests/integration/compiled-binary-e2e.test.ts' tests --unstable-worker-options --unstable-net",
+        "test:integration:cli": "DENO_TESTING=1 VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --no-check --parallel --allow-all --unstable-worker-options --unstable-net $(find cli -name '*.integration.test.ts')",
         "test:record": "VCR=record deno test --no-check --allow-all $(find cli -name '*.integration.test.ts' -path '*/commands/*')",
-        "test:coverage": "rm -rf coverage && deno task generate && VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --fail-fast --allow-all --v8-flags=--max-old-space-size=8192 --coverage=coverage '--ignore=tests/integration/compiled-binary-e2e.test.ts' --unstable-worker-options --unstable-net || exit 1",
-        "test:coverage:unit": "rm -rf coverage && deno task generate && VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --fail-fast --allow-all --v8-flags=--max-old-space-size=8192 --coverage=coverage '--ignore=tests,src/workflow/__tests__' --unstable-worker-options --unstable-net $(find src cli -name '*.test.ts*' ! -name '*.integration.test.ts*') || exit 1",
-        "test:coverage:integration": "rm -rf coverage && deno task generate && VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --fail-fast --allow-all --v8-flags=--max-old-space-size=8192 --coverage=coverage '--ignore=tests/e2e,tests/integration/compiled-binary-e2e.test.ts' tests --unstable-worker-options --unstable-net || exit 1",
+        "test:coverage": "rm -rf coverage && deno task generate && DENO_TESTING=1 VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --fail-fast --allow-all --v8-flags=--max-old-space-size=8192 --coverage=coverage '--ignore=tests/integration/compiled-binary-e2e.test.ts' --unstable-worker-options --unstable-net || exit 1",
+        "test:coverage:unit": "rm -rf coverage && deno task generate && DENO_TESTING=1 VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --fail-fast --allow-all --v8-flags=--max-old-space-size=8192 --coverage=coverage '--ignore=tests,src/workflow/__tests__' --unstable-worker-options --unstable-net $(find src cli -name '*.test.ts*' ! -name '*.integration.test.ts*') || exit 1",
+        "test:coverage:integration": "rm -rf coverage && deno task generate && DENO_TESTING=1 VF_DISABLE_LRU_INTERVAL=1 SSR_TRANSFORM_PER_PROJECT_LIMIT=0 REVALIDATION_PER_PROJECT_LIMIT=0 NODE_ENV=production LOG_FORMAT=text deno test --preload=src/schemas/_test-setup.ts --no-check --parallel --fail-fast --allow-all --v8-flags=--max-old-space-size=8192 --coverage=coverage '--ignore=tests/e2e,tests/integration/compiled-binary-e2e.test.ts' tests --unstable-worker-options --unstable-net || exit 1",
         "coverage:report": "deno coverage coverage --include=src/ --exclude=tests '--exclude=src/**/*_test.ts' '--exclude=src/**/*_test.tsx' '--exclude=src/**/*.test.ts' '--exclude=src/**/*.test.tsx' --lcov > coverage/lcov.info && deno run --allow-read scripts/lint/check-coverage.ts 80",
         "coverage:gate": "deno coverage coverage --include=src/ --exclude=tests '--exclude=src/**/*_test.ts' '--exclude=src/**/*_test.tsx' '--exclude=src/**/*.test.ts' '--exclude=src/**/*.test.tsx' --lcov > coverage/lcov.info && deno run --allow-read scripts/lint/check-coverage.ts 80",
         "coverage:ci:shard": "deno run --allow-read --allow-write --allow-run --allow-env scripts/test/coverage-ci.ts shard",

package/esm/src/agent/hosted/chat-request-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat-request-parser.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/hosted/chat-request-parser.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"chat-request-parser.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/hosted/chat-request-parser.ts"],"names":[],"mappings":"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"}

package/esm/src/agent/hosted/chat-request-parser.js

@@ -1,8 +1,10 @@
+import { stringifyUnknown } from "../../chat/conversation.js";
 import { buildHostedChatRequestInputFromRuntimeAgentInvocation, hostedChatRequestSchema, } from "./chat-request.js";
 import { RuntimeAgentRunInvocationSchema } from "../runtime/agent-invocation-contract.js";
 import { isRequestBodyTooLargeError, readBodyWithLimit, } from "../../security/input-validation/limits.js";
 import { DEFAULT_MAX_BODY_SIZE_BYTES } from "../../utils/constants/index.js";
 import { verifyHostedRuntimeSourceBinding, } from "./runtime-source-binding.js";
+import { getHostedChatUiToolIdentity } from "./chat-request-tool-part.js";
 async function parseRequestJson(request) {
     let body;
     try {
@@ -37,6 +39,104 @@ function normalizeProjectSlug(projectSlug) {
     const normalized = projectSlug?.trim();
     return normalized || undefined;
 }
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mapRawToolCallState(state) {
+    switch (state) {
+        case "streaming":
+            return "input-streaming";
+        case "pending":
+            return "pending";
+        case "error":
+            return "completed";
+        default:
+            return "completed";
+    }
+}
+function normalizeHostedChatRequestMessages(messages) {
+    const knownToolNames = new Map();
+    const knownToolInputs = new Map();
+    return messages.map((message) => {
+        const parts = [];
+        const partIndexByToolCallId = new Map();
+        for (const part of message.parts) {
+            const uiToolIdentity = getHostedChatUiToolIdentity(part);
+            if (uiToolIdentity) {
+                knownToolNames.set(uiToolIdentity.toolCallId, uiToolIdentity.toolName);
+                const input = isRecord(part)
+                    ? part["input"]
+                    : undefined;
+                if (isRecord(input)) {
+                    knownToolInputs.set(uiToolIdentity.toolCallId, input);
+                }
+                partIndexByToolCallId.set(uiToolIdentity.toolCallId, parts.length);
+            }
+            if (isRecord(part) && part.type === "tool_call" && "id" in part && "name" in part) {
+                const rawPart = part;
+                const rawId = rawPart["id"];
+                const rawName = rawPart["name"];
+                const toolCallId = typeof rawId === "string" ? rawId : "";
+                const toolName = typeof rawName === "string" ? rawName : "";
+                const state = typeof part.state === "string" ? part.state : "completed";
+                if (!toolCallId || !toolName)
+                    continue;
+                const input = isRecord(part.input) ? part.input : {};
+                knownToolNames.set(toolCallId, toolName);
+                knownToolInputs.set(toolCallId, input);
+                partIndexByToolCallId.set(toolCallId, parts.length);
+                parts.push({
+                    type: "tool_call",
+                    toolCallId,
+                    toolName,
+                    input,
+                    state: mapRawToolCallState(state),
+                });
+                continue;
+            }
+            if (isRecord(part) && part.type === "tool_result") {
+                const toolCallId = typeof part.tool_call_id === "string" ? part.tool_call_id : "";
+                const explicitToolName = typeof part.tool_name === "string" ? part.tool_name : "";
+                const toolName = explicitToolName || knownToolNames.get(toolCallId);
+                if (!toolCallId || !toolName)
+                    continue;
+                const resultPart = {
+                    type: "tool_call",
+                    toolCallId,
+                    toolName,
+                    input: knownToolInputs.get(toolCallId) ?? {},
+                    state: part.is_error === true ? "output-error" : "output-available",
+                    output: part.output,
+                    ...(part.is_error === true
+                        ? { errorText: stringifyUnknown(part.output ?? "Tool error") }
+                        : {}),
+                };
+                const existingIndex = partIndexByToolCallId.get(toolCallId);
+                if (existingIndex !== undefined) {
+                    const existingPart = parts[existingIndex];
+                    if (existingPart && isRecord(existingPart)) {
+                        parts[existingIndex] = {
+                            ...existingPart,
+                            state: resultPart.state,
+                            output: resultPart.output,
+                            ...(resultPart.errorText ? { errorText: resultPart.errorText } : {}),
+                        };
+                    }
+                }
+                else {
+                    parts.push(resultPart);
+                }
+                continue;
+            }
+            parts.push(part);
+        }
+        return {
+            ...message,
+            role: message.role,
+            parts,
+        };
+    });
+}
 function isBlankProjectSlug(projectSlug) {
     return projectSlug !== undefined && !normalizeProjectSlug(projectSlug);
 }
@@ -105,7 +205,7 @@ export async function buildParsedHostedChatRequest(input) {
         agentId: input.agentId,
         userId: input.userId,
         authToken: input.authToken,
-        messages: messages,
+        messages: normalizeHostedChatRequestMessages(messages),
         validatedContext,
         projectId,
         projectSlug: verifiedProjectSlug,

package/esm/src/agent/hosted/chat-request-tool-part.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolve the identity carried by a normalized UI tool part.
+ *
+ * Static tools derive their name from `tool-<name>` while dynamic and replay
+ * tool parts carry an explicit `toolName`.
+ */
+export declare function getHostedChatUiToolIdentity(part: unknown): {
+    toolCallId: string;
+    toolName: string;
+} | null;
+//# sourceMappingURL=chat-request-tool-part.d.ts.map

package/esm/src/agent/hosted/chat-request-tool-part.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-request-tool-part.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/hosted/chat-request-tool-part.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,OAAO,GACZ;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAWjD"}

package/esm/src/agent/hosted/chat-request-tool-part.js

@@ -0,0 +1,19 @@
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Resolve the identity carried by a normalized UI tool part.
+ *
+ * Static tools derive their name from `tool-<name>` while dynamic and replay
+ * tool parts carry an explicit `toolName`.
+ */
+export function getHostedChatUiToolIdentity(part) {
+    if (!isRecord(part) || typeof part.type !== "string") {
+        return null;
+    }
+    const toolCallId = typeof part.toolCallId === "string" ? part.toolCallId : "";
+    const explicitToolName = typeof part.toolName === "string" ? part.toolName : "";
+    const derivedToolName = part.type.startsWith("tool-") ? part.type.slice("tool-".length) : "";
+    const toolName = explicitToolName || derivedToolName;
+    return toolCallId && toolName ? { toolCallId, toolName } : null;
+}

package/esm/src/agent/hosted/chat-request.d.ts

@@ -105,6 +105,18 @@ export declare const getHostedChatRequestSchema: () => import("../../internal-ag
         }) | import("../../extensions/schema/schema-validator.js").InferShape<{
             type: import("../../internal-agents/schema.js").Schema<`data-${string}`>;
             data: import("../../internal-agents/schema.js").Schema<unknown>;
+        }> | import("../../extensions/schema/schema-validator.js").InferShape<{
+            type: import("../../internal-agents/schema.js").Schema<"tool_call">;
+            id: import("../../internal-agents/schema.js").Schema<string>;
+            name: import("../../internal-agents/schema.js").Schema<string>;
+            input: import("../../internal-agents/schema.js").Schema<Record<string, unknown>>;
+            state: import("../../internal-agents/schema.js").Schema<string>;
+        }> | import("../../extensions/schema/schema-validator.js").InferShape<{
+            type: import("../../internal-agents/schema.js").Schema<"tool_result">;
+            tool_call_id: import("../../internal-agents/schema.js").Schema<string>;
+            output: import("../../internal-agents/schema.js").Schema<unknown>;
+            is_error: import("../../internal-agents/schema.js").Schema<boolean | undefined>;
+            tool_name: import("../../internal-agents/schema.js").Schema<string | undefined>;
         }>)[]>;
         metadata: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
     }>[]>;
@@ -206,6 +218,18 @@ export declare const hostedChatRequestSchema: import("../../internal-agents/sche
         }) | import("../../extensions/schema/schema-validator.js").InferShape<{
             type: import("../../internal-agents/schema.js").Schema<`data-${string}`>;
             data: import("../../internal-agents/schema.js").Schema<unknown>;
+        }> | import("../../extensions/schema/schema-validator.js").InferShape<{
+            type: import("../../internal-agents/schema.js").Schema<"tool_call">;
+            id: import("../../internal-agents/schema.js").Schema<string>;
+            name: import("../../internal-agents/schema.js").Schema<string>;
+            input: import("../../internal-agents/schema.js").Schema<Record<string, unknown>>;
+            state: import("../../internal-agents/schema.js").Schema<string>;
+        }> | import("../../extensions/schema/schema-validator.js").InferShape<{
+            type: import("../../internal-agents/schema.js").Schema<"tool_result">;
+            tool_call_id: import("../../internal-agents/schema.js").Schema<string>;
+            output: import("../../internal-agents/schema.js").Schema<unknown>;
+            is_error: import("../../internal-agents/schema.js").Schema<boolean | undefined>;
+            tool_name: import("../../internal-agents/schema.js").Schema<string | undefined>;
         }>)[]>;
         metadata: import("../../internal-agents/schema.js").Schema<Record<string, unknown> | undefined>;
     }>[]>;

package/esm/src/agent/hosted/chat-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat-request.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/hosted/chat-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EACL,2BAA2B,EAG5B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAMzF,eAAO,MAAM,uCAAuC;;;;;;;;GAUnD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oCAAoC;;;;;;;;GAEhD,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;GAO/C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;GAAkD,CAAC;AAehG,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAUtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAC;AAE9E,uCAAuC;AACvC,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC;AAC3F,6CAA6C;AAC7C,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,yBAAyB,CAAC,UAAU,CAAC,CAAC;IAChD,OAAO,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC,CAAC;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,gBAAgB,CAAC,EAAE,oBAAoB,CAAC;IACxC,cAAc,CAAC,EAAE,wBAAwB,CAAC;CAC3C,CAAC;AA2BF,gFAAgF;AAChF,wBAAgB,8DAA8D,CAC5E,KAAK,EAAE,yBAAyB,GAC/B,iBAAiB,CAAC,gBAAgB,CAAC,CAcrC;AAED,sEAAsE;AACtE,wBAAgB,qDAAqD,CACnE,KAAK,EAAE,yBAAyB,GAC/B,sBAAsB,CA0BxB;AAED,gEAAgE;AAChE,wBAAgB,gDAAgD,CAC9D,KAAK,EAAE,yBAAyB,GAC/B,iBAAiB,CAInB"}
+{"version":3,"file":"chat-request.d.ts","sourceRoot":"","sources":["../../../../src/src/agent/hosted/chat-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EACL,2BAA2B,EAG5B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AAOzF,eAAO,MAAM,uCAAuC;;;;;;;;GAUnD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oCAAoC;;;;;;;;GAEhD,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;GAO/C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;GAAkD,CAAC;AAmZhG,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAUtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAC;AAE9E,uCAAuC;AACvC,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC;AAC3F,6CAA6C;AAC7C,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,yBAAyB,CAAC,UAAU,CAAC,CAAC;IAChD,OAAO,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAAC,CAAC;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,gBAAgB,CAAC,EAAE,oBAAoB,CAAC;IACxC,cAAc,CAAC,EAAE,wBAAwB,CAAC;CAC3C,CAAC;AA2BF,gFAAgF;AAChF,wBAAgB,8DAA8D,CAC5E,KAAK,EAAE,yBAAyB,GAC/B,iBAAiB,CAAC,gBAAgB,CAAC,CAcrC;AAED,sEAAsE;AACtE,wBAAgB,qDAAqD,CACnE,KAAK,EAAE,yBAAyB,GAC/B,sBAAsB,CA0BxB;AAED,gEAAgE;AAChE,wBAAgB,gDAAgD,CAC9D,KAAK,EAAE,yBAAyB,GAC/B,iBAAiB,CAInB"}

package/esm/src/agent/hosted/chat-request.js

@@ -1,5 +1,6 @@
 import { getChatRequestContextSchema, getChatUiMessagePartSchema, getChatUiMessageRoleSchema, } from "../../chat/types.js";
 import { defineSchema, lazySchema } from "../../schemas/index.js";
+import { getHostedChatUiToolIdentity } from "./chat-request-tool-part.js";
 const getDurableRootRunIdSchema = defineSchema((v) => v.string().min(1).max(128).regex(/^[a-zA-Z0-9_-]+$/));
 export const getHostedDurableRootRunDescriptorSchema = defineSchema((v) => v.object({
     runId: getDurableRootRunIdSchema(),
@@ -24,13 +25,308 @@ export const getHostedChatRuntimeOverridesSchema = defineSchema((v) => v.object(
  * @deprecated Use getHostedChatRuntimeOverridesSchema()
  */
 export const hostedChatRuntimeOverridesSchema = lazySchema(getHostedChatRuntimeOverridesSchema);
+const getHostedChatRawToolCallPartSchema = defineSchema((v) => v.object({
+    type: v.literal("tool_call"),
+    id: v.string().min(1),
+    name: v.string().min(1),
+    input: v.record(v.string(), v.unknown()),
+    state: v.enum(["streaming", "pending", "completed", "error"]),
+}).strip());
+const getHostedChatRawToolResultPartSchema = defineSchema((v) => v.object({
+    type: v.literal("tool_result"),
+    tool_call_id: v.string().min(1),
+    output: v.unknown(),
+    is_error: v.boolean().optional(),
+    tool_name: v.string().min(1).optional(),
+}).strip());
+const getHostedChatRequestMessagePartSchema = defineSchema((v) => v.union([
+    getChatUiMessagePartSchema(),
+    getHostedChatRawToolCallPartSchema(),
+    getHostedChatRawToolResultPartSchema(),
+]));
+function isHostedChatUiToolPartCandidate(part) {
+    if (!isRecord(part) || typeof part.type !== "string") {
+        return false;
+    }
+    return (typeof part.toolCallId === "string" && part.toolCallId.length > 0 &&
+        (part.type === "dynamic-tool" || part.type === "tool_call" || part.type.startsWith("tool-")));
+}
+function isHostedChatToolResultPart(part) {
+    if (!isRecord(part)) {
+        return false;
+    }
+    if (part.type === "tool_result") {
+        return true;
+    }
+    return (getHostedChatUiToolIdentity(part) !== null && "state" in part &&
+        (part.state === "output-available" || part.state === "output-error" ||
+            part.state === "output-denied" || part.state === "error"));
+}
+function hasHostedChatNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function isHostedChatProviderVisibleNonToolPart(role, part) {
+    if (!isRecord(part)) {
+        return false;
+    }
+    if (role === "system") {
+        return part.type === "text" && typeof part.text === "string" && part.text.length > 0;
+    }
+    if (role === "user") {
+        return (part.type === "text" && typeof part.text === "string" && part.text.length > 0 ||
+            (part.type === "file" || part.type === "image") &&
+                typeof part.mediaType === "string" && typeof part.url === "string");
+    }
+    if (role === "assistant") {
+        return (part.type === "text" && typeof part.text === "string" && part.text.length > 0 ||
+            part.type === "reasoning" &&
+                (hasHostedChatNonEmptyString(part.text) ||
+                    hasHostedChatNonEmptyString(part.signature) ||
+                    hasHostedChatNonEmptyString(part.redactedData)) ||
+            (part.type === "file" || part.type === "image") &&
+                typeof part.mediaType === "string" && typeof part.url === "string");
+    }
+    return false;
+}
 const getHostedChatRequestMessageSchema = defineSchema((v) => v.object({
     id: v.string().min(1),
     role: getChatUiMessageRoleSchema(),
-    parts: v.array(getChatUiMessagePartSchema()),
+    parts: v.array(getHostedChatRequestMessagePartSchema()),
     metadata: v.record(v.string(), v.unknown()).optional(),
 }).strip());
-const getHostedChatRequestMessagesSchema = defineSchema((v) => v.array(getHostedChatRequestMessageSchema()));
+const getHostedChatRequestMessagesSchema = defineSchema((v) => v.array(getHostedChatRequestMessageSchema()).superRefine((messages, ctx) => {
+    const knownToolNames = new Map();
+    const knownToolResultIds = new Set();
+    const openToolCalls = new Map();
+    const recordToolCall = (toolCallId, toolName, path, options) => {
+        rejectOpenToolCallsBeforeNewCall(options.messageIndex);
+        if (knownToolNames.has(toolCallId)) {
+            ctx.addIssue({
+                code: "custom",
+                message: "tool_call id must be unique",
+                path,
+            });
+            return false;
+        }
+        knownToolNames.set(toolCallId, toolName);
+        openToolCalls.set(toolCallId, {
+            toolName,
+            path,
+            originMessageIndex: options.messageIndex,
+            requiresResult: options?.requiresResult === true,
+            sawLaterNonResultContent: false,
+        });
+        return true;
+    };
+    const rejectUnresolvedTerminalToolCalls = (message) => {
+        let rejected = false;
+        for (const openToolCall of openToolCalls.values()) {
+            if (!openToolCall.requiresResult) {
+                continue;
+            }
+            rejected = true;
+            ctx.addIssue({
+                code: "custom",
+                message,
+                path: openToolCall.path,
+            });
+        }
+        if (rejected) {
+            openToolCalls.clear();
+        }
+        return rejected;
+    };
+    const closeOpenBatchBeforeContinuation = () => {
+        rejectUnresolvedTerminalToolCalls("terminal tool_call requires an adjacent tool_result before conversation continuation");
+        openToolCalls.clear();
+    };
+    const rejectOpenToolCallsBeforeNewCall = (messageIndex) => {
+        for (const [toolCallId, openToolCall] of openToolCalls) {
+            if (openToolCall.originMessageIndex === messageIndex &&
+                !openToolCall.sawLaterNonResultContent) {
+                continue;
+            }
+            if (openToolCall.requiresResult) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: openToolCall.originMessageIndex === messageIndex
+                        ? "terminal tool_call requires a same-message tool_result before assistant continuation"
+                        : "terminal tool_call requires an adjacent tool_result before conversation continuation",
+                    path: openToolCall.path,
+                });
+            }
+            openToolCalls.delete(toolCallId);
+        }
+    };
+    const handleNonResultContent = (messageIndex) => {
+        for (const [toolCallId, openToolCall] of openToolCalls) {
+            if (openToolCall.originMessageIndex !== messageIndex) {
+                if (openToolCall.requiresResult) {
+                    ctx.addIssue({
+                        code: "custom",
+                        message: "terminal tool_call requires an adjacent tool_result before conversation continuation",
+                        path: openToolCall.path,
+                    });
+                }
+                openToolCalls.delete(toolCallId);
+                continue;
+            }
+            openToolCalls.set(toolCallId, {
+                ...openToolCall,
+                sawLaterNonResultContent: true,
+            });
+        }
+    };
+    const closeOpenBatchAfterSameMessageContinuation = () => {
+        for (const [toolCallId, openToolCall] of openToolCalls) {
+            if (!openToolCall.sawLaterNonResultContent) {
+                continue;
+            }
+            if (openToolCall.requiresResult) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "terminal tool_call requires a same-message tool_result before assistant continuation",
+                    path: openToolCall.path,
+                });
+            }
+            openToolCalls.delete(toolCallId);
+        }
+    };
+    const validateToolResult = (toolCallId, toolName, toolCallIdPath, toolNamePath) => {
+        if (knownToolResultIds.has(toolCallId)) {
+            ctx.addIssue({
+                code: "custom",
+                message: "tool_result for tool_call_id must be unique",
+                path: toolCallIdPath,
+            });
+            return;
+        }
+        knownToolResultIds.add(toolCallId);
+        const knownToolName = knownToolNames.get(toolCallId);
+        if (!knownToolName) {
+            ctx.addIssue({
+                code: "custom",
+                message: "tool_result requires a preceding matching tool_call",
+                path: toolCallIdPath,
+            });
+            return;
+        }
+        const openToolCall = openToolCalls.get(toolCallId);
+        if (!openToolCall) {
+            ctx.addIssue({
+                code: "custom",
+                message: "tool_result requires an adjacent terminal tool_call",
+                path: toolCallIdPath,
+            });
+            return;
+        }
+        openToolCalls.delete(toolCallId);
+        if (toolName && toolName !== openToolCall.toolName) {
+            ctx.addIssue({
+                code: "custom",
+                message: "tool_result tool_name must match its preceding tool_call",
+                path: toolNamePath,
+            });
+        }
+    };
+    const getFirstProviderVisiblePart = (role, parts) => {
+        return parts.find((part) => isHostedChatToolResultPart(part) ||
+            isHostedChatUiToolPartCandidate(part) ||
+            (isRecord(part) && part.type === "tool_call" && "id" in part && "name" in part) ||
+            isHostedChatProviderVisibleNonToolPart(role, part));
+    };
+    for (const [messageIndex, message] of messages.entries()) {
+        const firstPart = getFirstProviderVisiblePart(message.role, message.parts);
+        if (firstPart && openToolCalls.size > 0 && !isHostedChatToolResultPart(firstPart)) {
+            closeOpenBatchBeforeContinuation();
+        }
+        for (const [partIndex, part] of message.parts.entries()) {
+            const uiToolIdentity = getHostedChatUiToolIdentity(part);
+            const isRawToolCall = part.type === "tool_call" && "id" in part && "name" in part;
+            if (isRawToolCall && message.role !== "assistant") {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "tool_call is only allowed in assistant messages",
+                    path: [messageIndex, "parts", partIndex, "type"],
+                });
+                continue;
+            }
+            if (!uiToolIdentity && !isRawToolCall && isHostedChatUiToolPartCandidate(part)) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "tool UI parts require a non-empty toolName",
+                    path: [messageIndex, "parts", partIndex, "toolName"],
+                });
+                continue;
+            }
+            if (uiToolIdentity && message.role !== "assistant" && message.role !== "tool") {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "tool UI parts are only allowed in assistant or tool messages",
+                    path: [messageIndex, "parts", partIndex, "type"],
+                });
+                continue;
+            }
+            if (part.type === "tool_result" && message.role !== "assistant" && message.role !== "tool") {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "tool_result is only allowed in assistant or tool messages",
+                    path: [messageIndex, "parts", partIndex, "type"],
+                });
+                continue;
+            }
+            if (isRawToolCall) {
+                recordToolCall(part.id, part.name, [messageIndex, "parts", partIndex, "id"], {
+                    messageIndex,
+                    requiresResult: part.state === "completed" || part.state === "error",
+                });
+                continue;
+            }
+            if (uiToolIdentity) {
+                if (message.role === "assistant") {
+                    recordToolCall(uiToolIdentity.toolCallId, uiToolIdentity.toolName, [
+                        messageIndex,
+                        "parts",
+                        partIndex,
+                        "toolCallId",
+                    ], {
+                        messageIndex,
+                        requiresResult: "state" in part && part.state === "completed",
+                    });
+                }
+                const hasUiToolResult = "state" in part &&
+                    (part.state === "output-available" || part.state === "output-error" ||
+                        part.state === "output-denied" || part.state === "error");
+                if (message.role === "tool" && !hasUiToolResult) {
+                    ctx.addIssue({
+                        code: "custom",
+                        message: "tool message UI parts require a result-bearing state",
+                        path: [messageIndex, "parts", partIndex, "state"],
+                    });
+                    continue;
+                }
+                if (hasUiToolResult) {
+                    validateToolResult(uiToolIdentity.toolCallId, uiToolIdentity.toolName, [messageIndex, "parts", partIndex, "toolCallId"], [
+                        messageIndex,
+                        "parts",
+                        partIndex,
+                        "toolName" in part ? "toolName" : "type",
+                    ]);
+                }
+                continue;
+            }
+            if (part.type !== "tool_result") {
+                if (isHostedChatProviderVisibleNonToolPart(message.role, part)) {
+                    handleNonResultContent(messageIndex);
+                }
+                continue;
+            }
+            validateToolResult(part.tool_call_id, part.tool_name, [messageIndex, "parts", partIndex, "tool_call_id"], [messageIndex, "parts", partIndex, "tool_name"]);
+        }
+        closeOpenBatchAfterSameMessageContinuation();
+    }
+    rejectUnresolvedTerminalToolCalls("terminal tool_call requires a matching tool_result");
+}));
 export const getHostedChatRequestSchema = defineSchema((v) => v.object({
     messages: getHostedChatRequestMessagesSchema(),
     context: getChatRequestContextSchema(),

package/esm/src/chat/conversation.d.ts

@@ -1,5 +1,5 @@
 import type { InferSchema } from "../extensions/schema/index.js";
-import type { ChatUiMessage, ChatUiMessagePart, ProviderModelMessage } from "./types.js";
+import type { ChatUiMessage, ChatUiMessagePart, ChatUiMessageRole, ProviderModelMessage } from "./types.js";
 declare const PROVIDER_MODEL_MESSAGE_SOURCE_ID: unique symbol;
 /** Provider model message plus local-only source metadata. */
 export type ProviderModelMessageWithSourceId = ProviderModelMessage & {
@@ -204,6 +204,27 @@ type ToolUiPart = Extract<ChatUiMessagePart, {
     toolCallId: string;
     state: string;
 }>;
+type RawToolCallMessagePart = Extract<MessagePart, {
+    type: "tool_call";
+}>;
+type RawToolResultMessagePart = Extract<MessagePart, {
+    type: "tool_result";
+}>;
+/** Stored tool-call replay part accepted by provider conversion. */
+export type ChatProviderModelInputToolCallPart = RawToolCallMessagePart;
+/** Stored tool-result replay part accepted by provider conversion. */
+export type ChatProviderModelInputToolResultPart = RawToolResultMessagePart & {
+    tool_name?: string;
+};
+/** Message part accepted by provider conversion. */
+export type ChatProviderModelInputPart = ChatUiMessagePart | ChatProviderModelInputToolCallPart | ChatProviderModelInputToolResultPart;
+/** Message accepted by provider conversion. */
+export interface ChatProviderModelInputMessage<TMessageMetadata = unknown> {
+    id: string;
+    role: ChatUiMessageRole;
+    parts: ChatProviderModelInputPart[];
+    metadata?: TMessageMetadata;
+}
 /** Shared UUID pattern value. */
 export declare const UUID_PATTERN: RegExp;
 /** Check whether a value is a UUID. */
@@ -252,7 +273,19 @@ export declare function isTextPart(value: unknown): value is TextPartLike;
 export declare function isReasoningPart(value: unknown): value is ReasoningPartLike;
 /** Message shape for extract text from. */
 export declare function extractTextFromMessage(message: ProviderModelMessage): string;
+/** Tool replay parts that are valid to expose to provider conversion. */
+export type ProviderVisibleToolReplayMatches = {
+    preservedTransientToolParts: WeakSet<object>;
+    matchedToolCallParts: WeakSet<object>;
+    matchedToolResultParts: WeakSet<object>;
+    matchedToolResultNames: WeakMap<object, string>;
+    toolCallPartsStartingNewBatch: WeakSet<object>;
+    supersededToolCallParts: WeakSet<object>;
+    supersededToolResultParts: WeakSet<object>;
+};
+/** Find adjacent replay call/result occurrences using part object identity. */
+export declare function findProviderVisibleToolReplayMatches(messages: readonly ChatProviderModelInputMessage[]): ProviderVisibleToolReplayMatches;
 /** Convert UI messages to provider model messages. */
-export declare function convertUiMessagesToProviderModelMessages(messages: ChatUiMessage[]): ProviderModelMessage[];
+export declare function convertUiMessagesToProviderModelMessages(messages: readonly ChatProviderModelInputMessage[]): ProviderModelMessage[];
 export {};
 //# sourceMappingURL=conversation.d.ts.map