dominds 1.13.2 → 1.15.2

package/dist/llm/gen/tool-call-context.d.ts

@@ -1,9 +1,10 @@
 import type { ChatMessage, FuncCallMsg } from '../client';
+type ToolCallMsg = FuncCallMsg;
 export declare function normalizeToolCallPairs(context: readonly ChatMessage[]): ChatMessage[];
 export declare function hasAdjacentMatchingToolResult(context: readonly ChatMessage[], index: number): boolean;
 export declare function hasAdjacentMatchingToolCall(context: readonly ChatMessage[], index: number): boolean;
-export declare function formatUnresolvedToolCallText(call: FuncCallMsg): string;
-type ToolCallAdjacencyViolation = Readonly<{
+export declare function formatUnresolvedToolCallText(call: ToolCallMsg): string;
+export type ToolCallAdjacencyViolation = Readonly<{
     kind: 'unresolved_call';
     index: number;
     callId: string;
@@ -15,5 +16,9 @@ type ToolCallAdjacencyViolation = Readonly<{
     toolName: string;
 }>;
 export declare function findFirstToolCallAdjacencyViolation(context: readonly ChatMessage[]): ToolCallAdjacencyViolation | null;
+export declare function sanitizeToolContextForProvider(context: readonly ChatMessage[]): Readonly<{
+    messages: ChatMessage[];
+    droppedViolations: ToolCallAdjacencyViolation[];
+}>;
 export declare function formatToolCallAdjacencyViolation(violation: ToolCallAdjacencyViolation, location: string): string;
 export {};

package/dist/llm/gen/tool-call-context.js

@@ -5,7 +5,14 @@ exports.hasAdjacentMatchingToolResult = hasAdjacentMatchingToolResult;
 exports.hasAdjacentMatchingToolCall = hasAdjacentMatchingToolCall;
 exports.formatUnresolvedToolCallText = formatUnresolvedToolCallText;
 exports.findFirstToolCallAdjacencyViolation = findFirstToolCallAdjacencyViolation;
+exports.sanitizeToolContextForProvider = sanitizeToolContextForProvider;
 exports.formatToolCallAdjacencyViolation = formatToolCallAdjacencyViolation;
+function isToolCallMsg(msg) {
+    return msg?.type === 'func_call_msg';
+}
+function isToolResultMsg(msg) {
+    return msg?.type === 'func_result_msg';
+}
 function normalizeToolCallPairs(context) {
     // Providers differ in how strictly they validate tool call/result ordering. Dominds can
     // temporarily produce a block of calls followed by a block of results when tools run in
@@ -14,18 +21,18 @@ function normalizeToolCallPairs(context) {
     let i = 0;
     while (i < context.length) {
         const msg = context[i];
-        if (msg.type !== 'func_call_msg') {
+        if (!isToolCallMsg(msg)) {
             out.push(msg);
             i += 1;
             continue;
         }
         const calls = [];
-        while (i < context.length && context[i].type === 'func_call_msg') {
+        while (i < context.length && isToolCallMsg(context[i])) {
             calls.push(context[i]);
             i += 1;
         }
         const results = [];
-        while (i < context.length && context[i].type === 'func_result_msg') {
+        while (i < context.length && isToolResultMsg(context[i])) {
             results.push(context[i]);
             i += 1;
         }
@@ -66,14 +73,12 @@ function normalizeToolCallPairs(context) {
 function hasAdjacentMatchingToolResult(context, index) {
     const current = context[index];
     const next = context[index + 1];
-    return (current?.type === 'func_call_msg' && next?.type === 'func_result_msg' && current.id === next.id);
+    return isToolCallMsg(current) && isToolResultMsg(next) && current.id === next.id;
 }
 function hasAdjacentMatchingToolCall(context, index) {
     const previous = context[index - 1];
     const current = context[index];
-    return (previous?.type === 'func_call_msg' &&
-        current?.type === 'func_result_msg' &&
-        previous.id === current.id);
+    return isToolCallMsg(previous) && isToolResultMsg(current) && previous.id === current.id;
 }
 function formatUnresolvedToolCallText(call) {
     const argumentsText = call.arguments.trim();
@@ -85,7 +90,7 @@ function formatUnresolvedToolCallText(call) {
 function findFirstToolCallAdjacencyViolation(context) {
     for (let index = 0; index < context.length; index += 1) {
         const msg = context[index];
-        if (msg.type === 'func_call_msg' && !hasAdjacentMatchingToolResult(context, index)) {
+        if (isToolCallMsg(msg) && !hasAdjacentMatchingToolResult(context, index)) {
             return {
                 kind: 'unresolved_call',
                 index,
@@ -93,7 +98,7 @@ function findFirstToolCallAdjacencyViolation(context) {
                 toolName: msg.name,
             };
         }
-        if (msg.type === 'func_result_msg' && !hasAdjacentMatchingToolCall(context, index)) {
+        if (isToolResultMsg(msg) && !hasAdjacentMatchingToolCall(context, index)) {
             return {
                 kind: 'orphaned_result',
                 index,
@@ -104,15 +109,52 @@ function findFirstToolCallAdjacencyViolation(context) {
     }
     return null;
 }
+function sanitizeToolContextForProvider(context) {
+    const normalized = normalizeToolCallPairs(context);
+    const sanitized = [];
+    const droppedViolations = [];
+    for (let index = 0; index < normalized.length; index += 1) {
+        const msg = normalized[index];
+        if (isToolCallMsg(msg)) {
+            const next = normalized[index + 1];
+            if (isToolResultMsg(next) && next.id === msg.id) {
+                sanitized.push(msg, next);
+                index += 1;
+                continue;
+            }
+            droppedViolations.push({
+                kind: 'unresolved_call',
+                index,
+                callId: msg.id,
+                toolName: msg.name,
+            });
+            continue;
+        }
+        if (isToolResultMsg(msg)) {
+            droppedViolations.push({
+                kind: 'orphaned_result',
+                index,
+                callId: msg.id,
+                toolName: msg.name,
+            });
+            continue;
+        }
+        sanitized.push(msg);
+    }
+    return {
+        messages: sanitized,
+        droppedViolations,
+    };
+}
 function formatToolCallAdjacencyViolation(violation, location) {
     switch (violation.kind) {
         case 'unresolved_call':
-            return (`${location}: unresolved persisted func_call_msg detected ` +
+            return (`${location}: unresolved persisted tool call message detected ` +
                 `(callId=${violation.callId}, tool=${violation.toolName}, index=${violation.index}). ` +
-                'This means a tool call was persisted without a matching func_result_msg.');
+                'This means a tool call was persisted without a matching tool result message.');
         case 'orphaned_result':
-            return (`${location}: orphaned persisted func_result_msg detected ` +
+            return (`${location}: orphaned persisted tool result message detected ` +
                 `(callId=${violation.callId}, tool=${violation.toolName}, index=${violation.index}). ` +
-                'This means a tool result was restored without the immediately preceding func_call_msg.');
+                'This means a tool result was restored without the immediately preceding tool call message.');
     }
 }

package/dist/llm/gen.d.ts

@@ -7,8 +7,19 @@ export interface LlmStreamResult {
     usage: LlmUsageStats;
     llmGenModel?: string;
 }
+export type LlmBatchOutput = {
+    kind: 'message';
+    message: ChatMessage;
+} | {
+    kind: 'web_search_call';
+    call: LlmWebSearchCall;
+} | {
+    kind: 'native_tool_call';
+    call: OpenAiResponsesNativeToolCall;
+};
 export interface LlmBatchResult {
     messages: ChatMessage[];
+    outputs?: LlmBatchOutput[];
     usage: LlmUsageStats;
     llmGenModel?: string;
 }
@@ -26,9 +37,21 @@ export interface LlmRequestContext {
     dialogRootId: string;
     promptCacheKey?: string;
 }
-export type LlmWebSearchAction = {
+export type CodexLlmWebSearchAction = {
+    type: 'search';
+    query?: string;
+} | {
+    type: 'open_page';
+    url?: string;
+} | {
+    type: 'find_in_page';
+    url?: string;
+    pattern?: string;
+};
+export type OpenAiResponsesLlmWebSearchAction = {
     type: 'search';
     query?: string;
+    queries?: string[];
 } | {
     type: 'open_page';
     url?: string;
@@ -37,12 +60,45 @@ export type LlmWebSearchAction = {
     url?: string;
     pattern?: string;
 };
-export type LlmWebSearchCall = {
+export type CodexLlmWebSearchCall = {
+    source: 'codex';
+    phase: 'added' | 'done';
+    itemId: string;
+    status?: string;
+    action?: CodexLlmWebSearchAction;
+};
+export type OpenAiResponsesLlmWebSearchCall = {
+    source: 'openai_responses';
+    phase: 'added' | 'done';
+    itemId: string;
+    status?: string;
+    action?: OpenAiResponsesLlmWebSearchAction;
+};
+export type LlmWebSearchCall = CodexLlmWebSearchCall | OpenAiResponsesLlmWebSearchCall;
+export type OpenAiResponsesNativeToolItemType = 'file_search_call' | 'code_interpreter_call' | 'image_generation_call' | 'mcp_call' | 'mcp_list_tools' | 'mcp_approval_request' | 'custom_tool_call';
+export type OpenAiResponsesNonCustomNativeToolItemType = Exclude<OpenAiResponsesNativeToolItemType, 'custom_tool_call'>;
+export type OpenAiResponsesNonCustomNativeToolCall = {
+    source: 'openai_responses';
+    itemType: OpenAiResponsesNonCustomNativeToolItemType;
     phase: 'added' | 'done';
     itemId: string;
     status?: string;
-    action?: LlmWebSearchAction;
+    title?: string;
+    summary?: string;
+    detail?: string;
+};
+export type OpenAiResponsesCustomToolCall = {
+    source: 'openai_responses';
+    itemType: 'custom_tool_call';
+    phase: 'added' | 'done';
+    callId: string;
+    itemId?: string;
+    status?: string;
+    title?: string;
+    summary?: string;
+    detail?: string;
 };
+export type OpenAiResponsesNativeToolCall = OpenAiResponsesNonCustomNativeToolCall | OpenAiResponsesCustomToolCall;
 export interface LlmStreamReceiver {
     thinkingStart: () => Promise<void>;
     thinkingChunk: (chunk: string) => Promise<void>;
@@ -52,6 +108,7 @@ export interface LlmStreamReceiver {
     sayingFinish: () => Promise<void>;
     funcCall: (callId: string, name: string, args: string) => Promise<void>;
     webSearchCall?: (call: LlmWebSearchCall) => Promise<void>;
+    nativeToolCall?: (call: OpenAiResponsesNativeToolCall) => Promise<void>;
     streamError?: (detail: string) => Promise<void>;
 }
 export interface LlmGenerator {

package/dist/llm/kernel-driver/context.js

@@ -30,7 +30,7 @@ function hasUserPromptLikeAnchor(source) {
             continue;
         if ((msg.type === 'prompting_msg' ||
             msg.type === 'environment_msg' ||
-            msg.type === 'tellask_carryover_result_msg') &&
+            msg.type === 'tellask_carryover_msg') &&
             msg.role === 'user') {
             return true;
         }