@morlay/dsh-llm-openai-compatible 0.0.1 → 0.0.3

package/{lib/serialize.mjs → dist/translate-BzOJ1xx-.mjs}

@@ -1,33 +1,8 @@
-import { LlmError, contentHasImage, offloadRequestImages } from "@deepseek-ai/dsh-llm";
+import { EMPTY_RESPONSE_CODE, LlmError, ToolCallId, contentHasImage, offloadRequestImagesWithPolicy, textOnlyImageText } from "@deepseek-ai/dsh-llm";
 import { AttachmentError } from "@deepseek-ai/dsh-attachment";
 import { Buffer } from "node:buffer";
 //#region src/serialize.ts
-/**
-* Serialize harness messages into the AI SDK `LanguageModelV4Prompt` and merge
-* profile sampling defaults into call options for
-* `@ai-sdk/openai-compatible`. Request-level `GenerateOptions` wins, profile
-* values fill in, and anything still undefined is omitted so the provider's
-* own default applies. `topK` and the wire `reasoning_effort` spelling travel
-* through `providerOptions["openai-compatible"]`, which the provider
-* transparently forwards into the request body.
-* @module dsh-llm-openai-compatible/serialize
-*/
-/** Lead-in text of the user message that follows tool-result images. */
 const TOOL_RESULT_IMAGE_TEXT = "Attached image(s) from tool result:";
-/**
-* Resolve one reasoning effort to its wire spelling for the exact model.
-* `off` (and a `null` wire spelling) means *omit the field* — the provider
-* default applies; every other declared effort sends its configured value.
-* An effort the model does not declare fails here, before any network I/O:
-* that is where a bad request-level effort AND a bad profile default both
-* belong (describing a model must never throw, but executing a request must).
-* @param model - the configured model descriptor, or `undefined` for an
-*   unlisted model id (which carries no reasoning declaration).
-* @param effort - the resolved effort to send, or `undefined` to send none.
-* @returns the wire `reasoning_effort` value, or `undefined` to omit the field.
-* @throws LlmError `UNSUPPORTED_REASONING_EFFORT` when the model does not
-*   declare the effort.
-*/
 function resolveReasoningWire(model, effort) {
 	if (effort === void 0) return void 0;
 	const declaration = model?.reasoningEfforts;
@@ -40,19 +15,15 @@ function resolveReasoningWire(model, effort) {
 	if (wire === null) return void 0;
 	return wire;
 }
-/** Join the text blocks of a message (used for user/tool-result content). */
 function flattenText(blocks) {
 	return blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
 }
-/** Reject core image content before any text-flattening path can silently erase it. */
 function assertTextOnly(blocks) {
 	if (contentHasImage(blocks)) throw new LlmError("The OpenAI-compatible chat-completions adapter does not support image content in this message.", "UNSUPPORTED_CONTENT");
 }
-/** Reject roles whose wire format cannot carry image input. */
 function assertSupportedImageRoles(messages) {
 	for (const message of messages) if (message.role !== "user" && contentHasImage(message.content)) throw new LlmError(`The OpenAI-compatible chat-completions adapter cannot represent image content in a ${message.role} message.`, "UNSUPPORTED_CONTENT");
 }
-/** Resolve one durable image into its transient data-URL file part. */
 async function imagePart(block, attachments, signal) {
 	try {
 		const stored = await attachments.readImage(block.attachment, signal);
@@ -69,7 +40,6 @@ async function imagePart(block, attachments, signal) {
 		throw error;
 	}
 }
-/** Serialize one assistant message into prompt parts, recording tool names by call id. */
 function assistantParts(message, toolNames) {
 	const parts = [];
 	for (const block of message.content) switch (block.type) {
@@ -104,7 +74,6 @@ function assistantParts(message, toolNames) {
 	}
 	return parts;
 }
-/** Convert user blocks into prompt parts, resolving images through the resolver. */
 async function userParts(blocks, resolveImage, signal) {
 	const parts = [];
 	for (const block of blocks) switch (block.type) {
@@ -122,18 +91,6 @@ async function userParts(blocks, resolveImage, signal) {
 	}
 	return parts;
 }
-/**
-* Serialize the conversation into the AI SDK prompt. `tool-result` blocks
-* become standalone `{role: "tool"}` messages; the harness puts each tool
-* result in its own user-role message, so a mixed user message contributes
-* its text first and its tool results as separate wire messages after.
-* Tool-result images cannot ride a tool message, so they are buffered and
-* flushed into the next user message (or a dedicated one at the end).
-* @param messages - the harness conversation, in order.
-* @param resolveImage - image resolver for the image-capable path, or `undefined` for text-only.
-* @param signal - cancellation for attachment reads.
-* @returns the AI SDK prompt; order preserved.
-*/
 async function serializePrompt(messages, resolveImage, signal) {
 	if (resolveImage === void 0) for (const message of messages) assertTextOnly(message.content);
 	else assertSupportedImageRoles(messages);
@@ -202,7 +159,6 @@ async function serializePrompt(messages, resolveImage, signal) {
 	flushToolImages();
 	return prompt;
 }
-/** Serialize tool schemas to AI SDK function tools. */
 function serializeTools(options) {
 	const tools = options.tools?.map((tool) => ({
 		type: "function",
@@ -212,7 +168,6 @@ function serializeTools(options) {
 	}));
 	return tools !== void 0 && tools.length > 0 ? tools : void 0;
 }
-/** Merge profile sampling defaults under request-level values into call options. */
 function callOptionsWithPrompt(options, profile, model, prompt) {
 	const tools = serializeTools(options);
 	const temperature = options.temperature ?? profile.temperature;
@@ -235,13 +190,6 @@ function callOptionsWithPrompt(options, profile, model, prompt) {
 		...Object.keys(providerOptions["openai-compatible"] ?? {}).length > 0 ? { providerOptions } : {}
 	};
 }
-/**
-* Build the full call options for text-only content.
-* @param options - the harness request.
-* @param profile - resolved provider profile.
-* @param model - configured model descriptor, or `undefined` for unlisted ids.
-* @returns the AI SDK call options (settings + prompt + provider options).
-*/
 async function serializeCallOptions(options, profile, model) {
 	const system = options.system === void 0 ? [] : [{
 		role: "system",
@@ -250,18 +198,12 @@ async function serializeCallOptions(options, profile, model) {
 	const prompt = await serializePrompt(options.messages, void 0);
 	return callOptionsWithPrompt(options, profile, model, [...system, ...prompt]);
 }
-/**
-* Build one image-capable request while keeping durable bytes out of session
-* messages. Oversized oldest images become deterministic text before any
-* attachment read.
-* @param options - the harness request containing image-capable user content.
-* @param profile - resolved provider profile.
-* @param model - configured model descriptor, or `undefined` for unlisted ids.
-* @param images - the attachment resolver, request bound, and cancellation.
-* @returns the fully materialized call options.
-*/
 async function serializeCallOptionsWithImages(options, profile, model, images) {
-	const requestMessages = offloadRequestImages(options.messages, images.maxRequestImageBytes);
+	const requestMessages = offloadRequestImagesWithPolicy(options.messages, {
+		representation: "raw",
+		maxBytes: images.maxRequestImageBytes,
+		placeholder: (ref) => textOnlyImageText(ref)
+	});
 	const resolveImage = (block, signal) => imagePart(block, images.attachments, signal);
 	const system = options.system === void 0 ? [] : [{
 		role: "system",
@@ -271,6 +213,189 @@ async function serializeCallOptionsWithImages(options, profile, model, images) {
 	return callOptionsWithPrompt(options, profile, model, [...system, ...prompt]);
 }
 //#endregion
-export { resolveReasoningWire, serializeCallOptions, serializeCallOptionsWithImages };
-
-//# sourceMappingURL=serialize.mjs.map
+//#region src/translate.ts
+function mapFinishReason(reason) {
+	switch (reason.unified) {
+		case "stop": return { kind: "stop" };
+		case "tool-calls": return { kind: "tool-calls" };
+		case "length": return { kind: "max-tokens" };
+		default: return {
+			kind: "error",
+			failure: {
+				message: `model stopped: ${reason.raw ?? reason.unified}`,
+				code: (reason.raw ?? reason.unified).toUpperCase()
+			}
+		};
+	}
+}
+function mapUsage(usage) {
+	const cacheRead = usage.inputTokens.cacheRead;
+	const reasoning = usage.outputTokens.reasoning;
+	return {
+		inputTokens: usage.inputTokens.noCache ?? usage.inputTokens.total ?? 0,
+		outputTokens: usage.outputTokens.total ?? 0,
+		...cacheRead !== void 0 && cacheRead > 0 ? { cacheReadTokens: cacheRead } : {},
+		...reasoning !== void 0 && reasoning > 0 ? { reasoningTokens: reasoning } : {}
+	};
+}
+function closeBlock(block) {
+	switch (block.kind) {
+		case "text": return {
+			type: "text",
+			text: block.text
+		};
+		case "reasoning": return {
+			type: "reasoning",
+			text: block.text
+		};
+		case "tool-call": return {
+			type: "tool-call",
+			id: ToolCallId(block.callId ?? ""),
+			name: block.name ?? "",
+			arguments: block.text
+		};
+	}
+}
+async function* translate(stream) {
+	let nextIndex = 0;
+	const textBlocks = /* @__PURE__ */ new Map();
+	const reasoningBlocks = /* @__PURE__ */ new Map();
+	const toolBlocks = /* @__PURE__ */ new Map();
+	const toolQueue = [];
+	const order = [];
+	let pendingUsage;
+	let pendingFinish;
+	const open = (kind) => {
+		const block = {
+			index: nextIndex++,
+			kind,
+			text: ""
+		};
+		order.push(block);
+		return block;
+	};
+	for await (const part of stream) switch (part.type) {
+		case "stream-start":
+		case "response-metadata":
+		case "raw": break;
+		case "text-start": {
+			const block = open("text");
+			textBlocks.set(part.id, block);
+			yield {
+				type: "block-start",
+				index: block.index,
+				blockType: "text"
+			};
+			break;
+		}
+		case "text-delta": {
+			const block = textBlocks.get(part.id);
+			if (block === void 0) break;
+			block.text += part.delta;
+			yield {
+				type: "text-delta",
+				index: block.index,
+				text: part.delta
+			};
+			break;
+		}
+		case "text-end": break;
+		case "reasoning-start": {
+			const block = open("reasoning");
+			reasoningBlocks.set(part.id, block);
+			yield {
+				type: "block-start",
+				index: block.index,
+				blockType: "reasoning"
+			};
+			break;
+		}
+		case "reasoning-delta": {
+			const block = reasoningBlocks.get(part.id);
+			if (block === void 0) break;
+			block.text += part.delta;
+			yield {
+				type: "reasoning-delta",
+				index: block.index,
+				text: part.delta
+			};
+			break;
+		}
+		case "reasoning-end": break;
+		case "tool-input-start": {
+			const block = open("tool-call");
+			if (part.toolName !== void 0) block.name = part.toolName;
+			toolBlocks.set(part.id, block);
+			toolQueue.push(block);
+			yield {
+				type: "block-start",
+				index: block.index,
+				blockType: "tool-call"
+			};
+			break;
+		}
+		case "tool-input-delta": {
+			const block = toolBlocks.get(part.id);
+			if (block === void 0) break;
+			block.text += part.delta;
+			yield {
+				type: "tool-call-delta",
+				index: block.index,
+				id: ToolCallId(block.callId ?? part.id),
+				...block.name !== void 0 ? { name: block.name } : {},
+				argumentsDelta: part.delta
+			};
+			break;
+		}
+		case "tool-input-end": break;
+		case "tool-call":
+			applyToolCall(part, toolQueue);
+			break;
+		case "tool-result":
+		case "tool-approval-request":
+		case "custom":
+		case "file":
+		case "reasoning-file":
+		case "source": break;
+		case "finish":
+			pendingUsage = mapUsage(part.usage);
+			pendingFinish = mapFinishReason(part.finishReason);
+			for (const block of order) yield {
+				type: "block-end",
+				index: block.index,
+				block: closeBlock(block)
+			};
+			if (pendingUsage !== void 0) yield {
+				type: "usage",
+				usage: pendingUsage
+			};
+			const reason = pendingFinish ?? { kind: "stop" };
+			yield {
+				type: "finish",
+				reason: reason.kind === "stop" && order.length === 0 ? {
+					kind: "error",
+					failure: {
+						message: "model returned a completed response with no content",
+						code: EMPTY_RESPONSE_CODE
+					}
+				} : reason
+			};
+			return;
+		case "error": {
+			const error = part.error;
+			const cause = error instanceof Error ? error : void 0;
+			const message = cause?.message ?? (typeof error === "string" ? error : "provider stream error");
+			throw new LlmError(`OpenAI-compatible stream failed: ${message}`, "TRANSPORT", { cause });
+		}
+	}
+	throw new LlmError("AI SDK stream ended without a finish part", "STREAM_CLOSED");
+}
+function applyToolCall(part, toolQueue) {
+	const block = toolQueue.shift();
+	if (block === void 0) return;
+	block.callId = part.toolCallId;
+	block.name = part.toolName;
+	block.text = part.input;
+}
+//#endregion
+export { serializeCallOptions as a, resolveReasoningWire as i, mapUsage as n, serializeCallOptionsWithImages as o, translate as r, mapFinishReason as t };

package/dist/wire.d.mts

@@ -0,0 +1,37 @@
+import { c as ResolvedModelProfile, l as ResolvedProviderProfile } from "./adapter-CYd_pegB.mjs";
+import { FinishReason, GenerateOptions, StreamChunk, TokenUsage } from "@deepseek-ai/dsh-llm";
+import { LanguageModelV4FinishReason, LanguageModelV4FunctionTool, LanguageModelV4Prompt, LanguageModelV4StreamPart, LanguageModelV4Usage, SharedV4ProviderOptions } from "@ai-sdk/provider";
+import { AttachmentStore } from "@deepseek-ai/dsh-attachment";
+//#region src/serialize.d.ts
+type OpenAICompatibleProviderOptions = SharedV4ProviderOptions & {
+  "openai-compatible"?: {
+    reasoningEffort?: string;
+    top_k?: number;
+  };
+};
+interface OpenAICompatibleCallOptions {
+  prompt: LanguageModelV4Prompt;
+  maxOutputTokens?: number;
+  temperature?: number;
+  topP?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+  seed?: number;
+  stopSequences?: string[];
+  tools?: LanguageModelV4FunctionTool[];
+  providerOptions?: OpenAICompatibleProviderOptions;
+}
+declare function resolveReasoningWire(model: ResolvedModelProfile | undefined, effort: ResolvedProviderProfile["reasoning"] | undefined): string | undefined;
+declare function serializeCallOptions(options: GenerateOptions, profile: ResolvedProviderProfile, model: ResolvedModelProfile | undefined): Promise<OpenAICompatibleCallOptions>;
+declare function serializeCallOptionsWithImages(options: GenerateOptions, profile: ResolvedProviderProfile, model: ResolvedModelProfile | undefined, images: {
+  attachments: AttachmentStore;
+  maxRequestImageBytes: number;
+  signal?: AbortSignal;
+}): Promise<OpenAICompatibleCallOptions>;
+//#endregion
+//#region src/translate.d.ts
+declare function mapFinishReason(reason: LanguageModelV4FinishReason): FinishReason;
+declare function mapUsage(usage: LanguageModelV4Usage): TokenUsage;
+declare function translate(stream: ReadableStream<LanguageModelV4StreamPart>): AsyncGenerator<StreamChunk, void>;
+//#endregion
+export { OpenAICompatibleCallOptions, OpenAICompatibleProviderOptions, mapFinishReason, mapUsage, resolveReasoningWire, serializeCallOptions, serializeCallOptionsWithImages, translate };

package/dist/wire.mjs

@@ -0,0 +1,2 @@
+import { a as serializeCallOptions, i as resolveReasoningWire, n as mapUsage, o as serializeCallOptionsWithImages, r as translate, t as mapFinishReason } from "./translate-BzOJ1xx-.mjs";
+export { mapFinishReason, mapUsage, resolveReasoningWire, serializeCallOptions, serializeCallOptionsWithImages, translate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morlay/dsh-llm-openai-compatible",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "OpenAI-compatible LLM adapter plugin for DeepSeek Harness with configurable default sampling parameters (temperature / topP / topK / penalties / seed) over a providers dict.",
   "keywords": [
     "dsh",
@@ -13,41 +13,45 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/morlay/dsh-llm-openai-compatible.git"
+    "url": "https://github.com/morlay/better-session.git"
   },
   "files": [
-    "lib",
-    "cordis.patch.yml"
+    "dist",
+    "src",
+    "cordis.patch.yml",
+    "!**/__tests__"
   ],
   "type": "module",
   "exports": {
-    ".": {
-      "types": "./lib/index.d.mts",
-      "default": "./lib/index.mjs"
-    },
+    ".": "./dist/index.mjs",
+    "./invariant": "./dist/invariant.mjs",
+    "./wire": "./dist/wire.mjs",
     "./package.json": "./package.json",
     "./cordis.patch.yml": "./cordis.patch.yml"
   },
   "dependencies": {
     "@ai-sdk/openai-compatible": "^3.0.32",
     "@ai-sdk/provider": "^4.0.7",
-    "zod": "^4.4.3"
+    "@deepseek-ai/dsh-util-values": "^0.1.2-rc.1"
   },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-anonymous-user-id": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-attachment": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-launch-environment": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-settings": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-timeout": "^0.1.0-rc.8",
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-anonymous-user-id": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-attachment": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-credentials": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-launch-environment": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-llm": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-settings": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-timeout": "^0.1.2-rc.1",
+    "@deepseek-ai/schemastery": "^3.18.2"
   },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
     }
   },
-  "scripts": {}
+  "scripts": {
+    "build": "pnpm exec tsdown"
+  }
 }