dsh-lcx-codex 0.4.3 → 0.5.0-pre.1

package/lib/dsh-compat.js

@@ -19,6 +19,27 @@ export function sessionFromAgent(agent) {
     const session = agentLike(agent)?.session;
     return session instanceof Session ? session : undefined;
 }
+// Event-driven next-route cache for live Agents; no Session log reads or polling.
+const agentRouteStates = new WeakMap();
+export function recordAgentRouteEvent(session, event) {
+    if (!(session instanceof Session))
+        return;
+    if (event.type !== "model/selection" && event.type !== "request/header")
+        return;
+    const previous = agentRouteStates.get(session);
+    let config = previous?.config;
+    let pending = previous?.pending;
+    if (event.type === "model/selection")
+        pending = event.data;
+    else {
+        config = event.data.header.config;
+        // An in-flight old-route request must not consume a newer selection.
+        if (pending?.provider === event.data.header.config.provider &&
+            pending.model === event.data.header.config.model)
+            pending = undefined;
+    }
+    agentRouteStates.set(session, { config, pending });
+}
 export function readAgentRouteState(agent) {
     const value = agentLike(agent);
     return {
@@ -27,6 +48,22 @@ export function readAgentRouteState(agent) {
         sessionId: agentSessionId(value),
     };
 }
+/** Selected next-request route, for tool advertisement before header persistence. */
+export function readSelectedAgentRouteState(agent) {
+    const route = readAgentRouteState(agent);
+    const session = sessionFromAgent(agent);
+    if (!session)
+        return route;
+    // Cold/resumed Agents recover pending selection from DSH's public projection.
+    const projections = resolveScopedService(agent, "sessionProjections");
+    if (mutableService(projections) && typeof projections.stateOf === "function") {
+        const selection = Reflect.apply(projections.stateOf, projections, [session, "modelSelection"]);
+        if (mutableService(selection))
+            return { ...route, requestConfig: selection.pending ?? route.requestConfig };
+    }
+    const cached = agentRouteStates.get(session);
+    return cached ? { ...route, requestConfig: cached.pending ?? cached.config } : route;
+}
 export function scopedToolRuntime(agent) {
     const tools = resolveScopedService(agent, "tools");
     if (!mutableService(tools) || typeof tools.register !== "function")

package/lib/dsh-responses.js

@@ -1,5 +1,7 @@
-import { offloadedImageText, offloadRequestImagesWithPolicy, requestImageHandleText, resolveImageAttachmentAccess, } from "@deepseek-ai/dsh-llm";
-import { convertResponsesMessages, convertResponsesTools, createGrammarToolInputProperties, getBuiltinModels, } from "./pi-responses-runtime.js";
+import { IMAGE_OFFLOAD_REQUIRED_CODE, LlmError, offloadedImageText, projectOffloadedImages, requiredImageOffload, requestImageHandleText, resolveImageAttachmentAccess, } from "@deepseek-ai/dsh-llm";
+import { requestImageDimensions } from "@deepseek-ai/dsh-attachment";
+import { convertResponsesMessages, convertResponsesTools, createGrammarToolInputProperties, getBuiltinModels, normalizeContext, } from "./pi-responses-runtime.js";
+import { wasPi086ResponsesModel } from "./pi086-responses-allowlist.js";
 const DEFAULT_MAX_REQUEST_IMAGE_BYTES = 20 * 1024 * 1024;
 const DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET = 2048 * 2048;
 const DEFAULT_REQUEST_IMAGE_MAX_BYTES = 1024 * 1024;
@@ -87,42 +89,45 @@ export async function resolveModelImageSupport(ctx, route, signal) {
         return "unknown";
     }
 }
-function attachmentResolver(ctx, options) {
+function attachmentResolver(ctx, options, requestImages) {
     const attachments = attachmentServices(ctx?.attachments);
     return async (block, signal) => {
         if (attachments === undefined)
             throw error("LCX requires the DSH request-image attachment API", "LCX_COMPACT_IMAGE_API_UNAVAILABLE");
-        const request = await attachments.store.readImageRequest(block.attachment, { maxPixels: options.requestImagePixelBudget, maxBytes: options.requestImageMaxBytes }, signal);
+        const request = requestImages === undefined
+            ? await attachments.store.readImageRequest(block.attachment, { ...requestImageDimensions(block.attachment.width, block.attachment.height, options.requestImagePixelBudget), maxBytes: options.requestImageMaxBytes }, signal)
+            : requestImages.get(String(block.attachment.attachmentId));
+        if (request === undefined)
+            throw error("DSH attachment returned no request-image bytes", "LCX_COMPACT_IMAGE_UNAVAILABLE");
         const data = request.data;
         const mediaType = request.mediaType ?? block.attachment.mediaType;
         if (!(data instanceof Uint8Array) && !Buffer.isBuffer(data))
             throw error("DSH attachment returned no request-image bytes", "LCX_COMPACT_IMAGE_UNAVAILABLE");
         if (typeof mediaType !== "string" || !mediaType.startsWith("image/"))
             throw error("DSH attachment returned an invalid request-image media type", "LCX_COMPACT_IMAGE_UNAVAILABLE");
-        const ref = request.attachment ?? block.attachment;
         return {
             data: Buffer.from(data),
             mediaType,
-            ref,
+            ref: block.attachment,
             request,
-            access: imageAccess(ctx, attachments, ref),
+            access: imageAccess(ctx, attachments, block.attachment),
         };
     };
 }
-async function imagePart(block, ctx, options, imageMap) {
+async function imagePart(block, ctx, options, imageMap, requestImages) {
     if (options.imageSupport === "unsupported")
         return { type: "input_text", text: "[image omitted because the target model does not support image input]" };
-    const image = await attachmentResolver(ctx, options)(block, options.signal);
+    const image = await attachmentResolver(ctx, options, requestImages)(block, options.signal);
     if (Math.ceil(image.data.byteLength / 3) * 4 > options.maxRequestImageBytes)
         throw error("one image exceeds the configured LCX request image bound", "LCX_COMPACT_IMAGE_TOO_LARGE");
     const imageUrl = `data:${image.mediaType};base64,${image.data.toString("base64")}`;
     imageMap.set(imageUrl, structuredClone(image.ref));
     return { type: "input_image", detail: "auto", image_url: imageUrl };
 }
-async function piImageParts(block, ctx, options, imageMap) {
+async function piImageParts(block, ctx, options, imageMap, requestImages) {
     if (options.imageSupport === "unsupported")
         return [{ type: "text", text: "[image omitted because the target model does not support image input]" }];
-    const image = await attachmentResolver(ctx, options)(block, options.signal);
+    const image = await attachmentResolver(ctx, options, requestImages)(block, options.signal);
     if (Math.ceil(image.data.byteLength / 3) * 4 > options.maxRequestImageBytes)
         throw error("one image exceeds the configured LCX request image bound", "LCX_COMPACT_IMAGE_TOO_LARGE");
     const data = image.data.toString("base64");
@@ -292,17 +297,15 @@ function toPiAssistant(message, onReplayDegrade) {
         return foreignAssistant(message);
     }
 }
-async function piToolContent(blocks, ctx, options, imageMap) {
+async function piToolContent(blocks, ctx, options, imageMap, requestImages) {
     const content = [];
     for (const block of blocks) {
         if (block.type === "text")
             content.push({ type: "text", text: block.text });
         else if (block.type === "image")
-            content.push(...(await piImageParts(block, ctx, options, imageMap)));
+            content.push(...(await piImageParts(block, ctx, options, imageMap, requestImages)));
         else if (block.type === "reasoning")
             continue;
-        else if (block.type === "tool-result")
-            content.push(...(await piToolContent(block.content, ctx, options, imageMap)));
         else
             throw unsupportedContent(block.type);
     }
@@ -312,8 +315,6 @@ function projectFileContent(blocks, fileRequestText) {
     return blocks.map((block) => {
         if (block.type === "file")
             return { type: "text", text: fileRequestText(block.attachment) };
-        if (block.type === "tool-result")
-            return { ...block, content: projectFileContent(block.content, fileRequestText) };
         return block;
     });
 }
@@ -331,12 +332,38 @@ function projectFiles(messages, ctx) {
         content: projectFileContent(message.content, fileRequestText),
     }));
 }
+function collectRequestImageRefs(blocks, refs) {
+    for (const block of blocks) {
+        if (block.type === "image") {
+            if (block.offloaded !== true)
+                refs.set(String(block.attachment.attachmentId), block.attachment);
+        }
+    }
+}
+async function prepareRequestImageVersions(messages, ctx, options) {
+    const attachments = attachmentServices(ctx?.attachments);
+    if (attachments === undefined)
+        return new Map();
+    const refs = new Map();
+    for (const message of messages)
+        collectRequestImageRefs(message.content, refs);
+    const versions = await Promise.all([...refs.values()].map(async (ref) => {
+        const target = {
+            ...requestImageDimensions(ref.width, ref.height, options.requestImagePixelBudget),
+            maxBytes: options.requestImageMaxBytes,
+        };
+        return [String(ref.attachmentId), await attachments.store.readImageRequest(ref, target, options.signal)];
+    }));
+    return new Map(versions);
+}
 function flattenMessageText(message) {
-    return message.content
-        .map((block) => (block.type === "text" ? block.text : ""))
-        .join("");
+    return message.content.map((block) => {
+        if (block.type !== "text")
+            throw unsupportedContent(block.type);
+        return block.text;
+    }).join("");
 }
-async function dshToPiMessages(messages, ctx, options, imageMap) {
+async function dshToPiMessages(messages, ctx, options, imageMap, requestImages) {
     const result = [];
     const toolNames = new Map();
     for (const message of messages) {
@@ -344,6 +371,8 @@ async function dshToPiMessages(messages, ctx, options, imageMap) {
             result.push({ role: "user", content: flattenMessageText(message), timestamp: 0 });
             continue;
         }
+        if (message.role === "developer")
+            throw unsupportedContent("developer message");
         if (message.role === "assistant") {
             const assistant = toPiAssistant(message, options.onReplayDegrade);
             for (const block of assistant.content)
@@ -352,15 +381,17 @@ async function dshToPiMessages(messages, ctx, options, imageMap) {
             result.push(assistant);
             continue;
         }
+        if (message.role === "tool") {
+            const toolCallId = String(message.toolCallId);
+            result.push({ role: "toolResult", toolCallId, toolName: toolNames.get(toolCallId) ?? "unknown", content: await piToolContent(message.content, ctx, options, imageMap, requestImages), isError: message.isError === true, timestamp: 0 });
+            continue;
+        }
         const ordinary = [];
-        const toolResults = [];
         for (const block of message.content) {
             if (block.type === "text" || block.type === "image")
                 ordinary.push(block);
             else if (block.type === "reasoning")
                 continue;
-            else if (block.type === "tool-result")
-                toolResults.push(block);
             else
                 throw unsupportedContent(block.type);
         }
@@ -370,21 +401,18 @@ async function dshToPiMessages(messages, ctx, options, imageMap) {
                 if (block.type === "text")
                     content.push({ type: "text", text: block.text });
                 else if (block.type === "image")
-                    content.push(...(await piImageParts(block, ctx, options, imageMap)));
+                    content.push(...(await piImageParts(block, ctx, options, imageMap, requestImages)));
             }
             if (content.length > 0)
                 result.push({ role: "user", content, timestamp: 0 });
         }
-        for (const block of toolResults) {
-            if (block.type !== "tool-result")
-                continue;
-            const toolCallId = String(block.toolCallId);
-            result.push({ role: "toolResult", toolCallId, toolName: toolNames.get(toolCallId) ?? "unknown", content: await piToolContent(block.content, ctx, options, imageMap), addedToolNames: [], isError: block.isError === true, timestamp: 0 });
-        }
     }
     return result;
 }
 function builtinResponsesModel(provider, modelId) {
+    // Keep descriptor and wire capabilities within the same frozen catalog scope as route ownership.
+    if (!wasPi086ResponsesModel(provider, modelId))
+        return undefined;
     try {
         return getBuiltinModels(provider).find((model) => model.id === modelId && model.api === "openai-responses");
     }
@@ -405,6 +433,16 @@ export function resolvePiResponsesModel(options) {
     return { ...builtinRecord, ...explicit, id, name: stringValue(explicit.name, stringValue(builtinRecord.name, id)), api: "openai-responses", provider, baseUrl: stringValue(explicit.baseUrl, stringValue(route.baseURL, stringValue(builtinRecord.baseUrl))), reasoning: typeof explicit.reasoning === "boolean" ? explicit.reasoning : typeof builtinRecord.reasoning === "boolean" ? builtinRecord.reasoning : true, input, cost: explicit.cost ?? builtinRecord.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: positiveSafeInteger(explicit.contextWindow ?? builtinRecord.contextWindow, 262144), maxTokens: positiveSafeInteger(explicit.maxTokens ?? builtinRecord.maxTokens, 32768), ...(Object.keys(compat).length > 0 ? { compat } : {}) };
 }
 export async function serializeDshMessages(messages, ctx, options = {}) {
+    for (const message of messages) {
+        if (message.role === "developer")
+            throw unsupportedContent("developer message");
+        for (const block of message.content)
+            if (block.type === "tool-addition" || block.type === "tool-removal")
+                throw unsupportedContent(block.type);
+    }
+    for (const tool of options.tools ?? [])
+        if ("deferLoading" in tool && tool.deferLoading === true)
+            throw unsupportedContent("deferLoading tool declaration");
     const normalized = {
         imageSupport: options.imageSupport === "supported" || options.imageSupport === "unsupported" ? options.imageSupport : "unknown",
         signal: options.signal instanceof AbortSignal ? options.signal : undefined,
@@ -419,34 +457,40 @@ export async function serializeDshMessages(messages, ctx, options = {}) {
     const imageMap = new Map();
     const fileProjected = projectFiles(messages, ctx);
     const attachments = attachmentServices(ctx?.attachments);
-    const projected = offloadRequestImagesWithPolicy(fileProjected, {
-        representation: "base64", maxBytes: normalized.maxRequestImageBytes, byteQuantum: 1,
-        byteLength: (ref) => Math.min(ref.bytes, normalized.requestImageMaxBytes),
-        placeholder: (ref) => offloadedImageText(ref, attachments === undefined ? undefined : imageAccess(ctx, attachments, ref)),
-    });
+    const requestImages = normalized.imageSupport === "unsupported"
+        ? new Map()
+        : await prepareRequestImageVersions(fileProjected, ctx, normalized);
+    const offloadImages = attachments === undefined || normalized.imageSupport === "unsupported"
+        ? 0
+        : requiredImageOffload(fileProjected, { representation: "base64", maxBytes: normalized.maxRequestImageBytes }, (block) => {
+            // `requiredImageOffload` applies the base64 expansion itself for a
+            // base64 representation, so this reports raw request-version bytes.
+            const request = requestImages.get(String(block.attachment.attachmentId));
+            return request?.bytes ?? block.attachment.bytes;
+        });
+    if (offloadImages > 0) {
+        throw new LlmError(`LCX request images exceed the configured base64 bound; ${offloadImages} more oldest occurrence(s) must be offloaded.`, IMAGE_OFFLOAD_REQUIRED_CODE, { offloadImages });
+    }
+    const projected = projectOffloadedImages(fileProjected, (ref) => offloadedImageText(ref, attachments === undefined ? undefined : imageAccess(ctx, attachments, ref)));
     const model = resolvePiResponsesModel(normalized);
-    const context = { systemPrompt: normalized.systemPrompt, messages: await dshToPiMessages(projected, ctx, normalized, imageMap), tools: [...normalized.tools] };
+    const dshContext = { systemPrompt: normalized.systemPrompt, messages: await dshToPiMessages(projected, ctx, normalized, imageMap, requestImages), tools: [...normalized.tools] };
     const compat = isObject(model.compat) ? model.compat : {};
     const supportsStrictMode = compat.supportsStrictMode === true;
     const supportsOpenAIGrammarTools = compat.supportsOpenAIGrammarTools === true;
     const supportsAdditionalTools = compat.supportsAdditionalTools === true;
     const supportsToolSearch = compat.supportsToolSearch === true;
     const deferredToolsMode = supportsAdditionalTools ? "additional-tools" : supportsToolSearch ? "tool-search" : undefined;
-    const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, supportsOpenAIGrammarTools);
-    // DSH has no authoritative added-tool provenance; keep its full catalog immediate.
+    const grammarToolInputProperties = createGrammarToolInputProperties(dshContext.tools, supportsOpenAIGrammarTools);
+    // These routes consume no tool updates; projectToolUpdates supplies the current immediate declarations.
     const immediateTools = new Map();
-    for (const tool of context.tools)
+    for (const tool of dshContext.tools)
         if (tool.name)
             immediateTools.set(tool.name, tool);
-    const toolOptions = { supportsStrictMode, supportsOpenAIGrammarTools };
-    const piContext = {
-        systemPrompt: context.systemPrompt,
-        messages: context.messages,
-        tools: context.tools,
-    };
+    const toolOptions = { supportsStrictMode, supportsOpenAIGrammarTools, toolSearchResult: false };
+    const piContext = normalizeContext(dshContext);
     const piModel = model;
-    const convertedInput = convertResponsesMessages(piModel, piContext, new Set(["openai", "openai-codex", "opencode"]), { includeSystemPrompt: normalized.includeSystemPrompt, grammarToolInputProperties, deferredTools: new Map(), deferredToolsMode, toolOptions });
-    const input = restorePortableAssistantPhases(convertedInput, context.messages, { provider: model.provider, id: model.id, api: model.api });
+    const convertedInput = convertResponsesMessages(piModel, piContext, new Set(["openai", "openai-codex", "opencode"]), { includeSystemPrompt: normalized.includeSystemPrompt, grammarToolInputProperties, supportsAdditionalTools, supportsToolSearch, toolOptions });
+    const input = restorePortableAssistantPhases(convertedInput, dshContext.messages, { provider: model.provider, id: model.id, api: model.api });
     const tools = options.tools === undefined ? undefined : convertResponsesTools([...immediateTools.values()], toolOptions);
     return { input, imageMap, tools, model: piModel, grammarToolInputProperties, deferredToolsMode };
 }