@alint-js/model-adapter-acp 0.4.0 → 0.5.0

package/README.md

@@ -95,4 +95,5 @@ endpoint = "http://127.0.0.1:7419/v1"
 
 - Use an alint agent adapter when a rule intentionally depends on agent-specific behavior.
 - Do not use this package as an OpenAI Responses, realtime, audio, or image compatibility layer.
-- Streaming tool calls and parallel tool calls are not implemented yet; text streaming is supported.
+- Sequential tool calls work with streaming and non-streaming chat completions.
+- Parallel tool calls are not supported.

package/dist/index.mjs

@@ -179,6 +179,11 @@ function inputSchema(tool) {
 }
 //#endregion
 //#region src/gateway.ts
+const zeroUsage = {
+	inputTokens: 0,
+	outputTokens: 0,
+	totalTokens: 0
+};
 const openAIFunctionToolSchema = object({
 	function: object({
 		description: optional(string()),
@@ -265,6 +270,7 @@ var CompletionTurn = class {
 	#cancelSession;
 	#connection;
 	#connectionDisposed = false;
+	#deferredText;
 	#finished = false;
 	#options;
 	#outputs = new PromiseQueue();
@@ -278,6 +284,7 @@ var CompletionTurn = class {
 				this.#toolCallCount += 1;
 				this.#pendingCalls.set(call.id, call);
 				options.onPending(call, this);
+				this.#flushDeferredText();
 				this.#outputs.push({
 					call,
 					type: "tool-call"
@@ -336,6 +343,14 @@ var CompletionTurn = class {
 		this.#finished = true;
 		this.#options.onFinished(this, [...this.#pendingCalls.keys()]);
 	}
+	#flushDeferredText() {
+		const chunks = this.#deferredText;
+		this.#deferredText = void 0;
+		for (const text of chunks ?? []) this.#outputs.push({
+			text,
+			type: "text-delta"
+		});
+	}
 	#matchesContinuation(request, toolCallId) {
 		const initialMessages = this.#options.request.messages;
 		const initialPrefix = request.messages.slice(0, initialMessages.length);
@@ -345,6 +360,16 @@ var CompletionTurn = class {
 		const toolCalls = assistantMessage.tool_calls;
 		return Array.isArray(toolCalls) && toolCalls.some((call) => isRecord(call) && call.id === toolCallId && isRecord(call.function) && call.function.name === pendingCall.name && call.function.arguments === pendingCall.arguments);
 	}
+	#pushText(text) {
+		if (this.#deferredText) {
+			this.#deferredText.push(text);
+			return;
+		}
+		this.#outputs.push({
+			text,
+			type: "text-delta"
+		});
+	}
 	async #run() {
 		const { cwd, model, origin, request } = this.#options;
 		try {
@@ -373,27 +398,25 @@ var CompletionTurn = class {
 					this.#assertActive();
 					for (let attempt = 0; attempt < 2; attempt += 1) {
 						const callCountBeforePrompt = this.#toolCallCount;
-						const prompt = session.prompt(attempt === 0 ? renderMessages(request) : "The request requires a tool call. Call the available function before returning an answer.");
-						let text = "";
+						this.#deferredText = requiresTool(request.toolChoice) ? [] : void 0;
+						const prompt = session.prompt(attempt === 0 ? renderMessages(request) : ["The request requires a request-scoped MCP tool call.", `Call one of these functions before returning an answer: ${this.#options.tools.map((tool) => tool.function.name).join(", ")}.`].join(" "));
 						for (;;) {
 							const message = await session.nextUpdate();
 							if (message.kind === "stop") {
 								await prompt;
 								if (message.stopReason === "cancelled") throw new Error("The ACP agent cancelled the prompt.");
-								if (requiresTool(request.toolChoice) && this.#toolCallCount === callCountBeforePrompt) break;
+								if (requiresTool(request.toolChoice) && this.#toolCallCount === callCountBeforePrompt) {
+									this.#deferredText = void 0;
+									break;
+								}
 								this.#outputs.push({
 									stopReason: message.stopReason,
-									text,
 									type: "completion",
 									usage: message.response.usage
 								});
 								return;
 							}
-							if (message.update.sessionUpdate === "agent_message_chunk" && message.update.content.type === "text") if (request.stream) this.#outputs.push({
-								text: message.update.content.text,
-								type: "text-delta"
-							});
-							else text += message.update.content.text;
+							if (message.update.sessionUpdate === "agent_message_chunk" && message.update.content.type === "text") this.#pushText(message.update.content.text);
 						}
 					}
 					throw new Error("The ACP agent did not satisfy tool_choice after one retry.");
@@ -450,10 +473,6 @@ function createGateway(options) {
 		}
 		const toolResult = lastToolResult(request.messages);
 		let turn;
-		if (request.stream && (request.tools.length > 0 || toolResult)) {
-			event.res.status = 400;
-			return openAIError("Streaming tool calls are not supported.", "invalid_request_error");
-		}
 		if (toolResult) {
 			const pendingTurn = pendingTurns.get(toolResult.toolCallId);
 			if (!pendingTurn || !pendingTurn.resume(request, toolResult)) {
@@ -490,25 +509,20 @@ function createGateway(options) {
 			activeTurns.add(turn);
 			turn.start();
 		}
-		if (request.stream) return streamCompletion(turn, model.id);
+		if (request.stream) return streamCompletion(turn, model.id, options.onCompatibilityDiagnostic);
 		let output;
 		try {
-			output = await turn.nextOutput(event.req.signal);
+			output = await bufferCompletion(turn, event.req.signal);
 		} catch {
 			event.res.status = 500;
 			return openAIError("The ACP agent could not complete the request.", "server_error");
 		}
 		if (output.type === "tool-call") {
-			turn.armContinuation(output.call.id);
-			options.onCompatibilityDiagnostic?.({
-				field: "usage",
-				message: "ACP usage is unavailable while a deferred tool call is pending; zero usage was reported.",
-				value: null
-			});
+			deferToolCall(turn, output.call, options.onCompatibilityDiagnostic);
 			return chatCompletion(turn.modelId, {
 				finishReason: "tool_calls",
 				message: {
-					content: null,
+					content: output.text || null,
 					role: "assistant",
 					tool_calls: [{
 						function: {
@@ -519,13 +533,8 @@ function createGateway(options) {
 						type: "function"
 					}]
 				}
-			}, {
-				inputTokens: 0,
-				outputTokens: 0,
-				totalTokens: 0
-			});
+			}, zeroUsage);
 		}
-		if (output.type === "text-delta") throw new Error("Text deltas are only emitted for streaming requests.");
 		return chatCompletion(turn.modelId, {
 			finishReason: finishReason(output.stopReason),
 			message: {
@@ -620,6 +629,20 @@ function authorizeRequestTools(client) {
 		return { outcome: { outcome: "cancelled" } };
 	});
 }
+async function bufferCompletion(turn, signal) {
+	let text = "";
+	for (;;) {
+		const output = await turn.nextOutput(signal);
+		if (output.type === "text-delta") {
+			text += output.text;
+			continue;
+		}
+		return {
+			...output,
+			text
+		};
+	}
+}
 function chatCompletion(model, choice, usage) {
 	return {
 		choices: [{
@@ -631,11 +654,7 @@ function chatCompletion(model, choice, usage) {
 		id: `chatcmpl-${crypto.randomUUID()}`,
 		model,
 		object: "chat.completion",
-		...usage ? { usage: {
-			completion_tokens: usage.outputTokens,
-			prompt_tokens: usage.inputTokens,
-			total_tokens: usage.totalTokens
-		} } : {}
+		...usage ? { usage: toOpenAIUsage(usage) } : {}
 	};
 }
 function chatCompletionChunk(id, created, model, choices) {
@@ -664,6 +683,14 @@ function chatCompletionRequest(value) {
 function connectWith(client, connection, operation) {
 	return connection.kind === "agent-app" ? client.connectWith(connection.agent, operation) : client.connectWith(connection.stream, operation);
 }
+function deferToolCall(turn, call, onCompatibilityDiagnostic) {
+	turn.armContinuation(call.id);
+	onCompatibilityDiagnostic?.({
+		field: "usage",
+		message: "ACP usage is unavailable while a deferred tool call is pending; zero usage was reported.",
+		value: null
+	});
+}
 function enqueueSse(controller, encoder, value) {
 	controller.enqueue(encoder.encode(`data: ${JSON.stringify(value)}\n\n`));
 }
@@ -704,11 +731,12 @@ function openAIError(message, type) {
 }
 function renderMessages(request) {
 	const requiredTool = request.toolChoice && typeof request.toolChoice === "object" ? request.toolChoice.function.name : void 0;
+	const toolNames = request.tools.map((tool) => tool.function.name).join(", ");
 	return [
 		"Process this OpenAI chat transcript. Preserve message order and role intent.",
 		"Return only the assistant response requested by the transcript.",
-		request.toolChoice === "required" ? "You must call one of the supplied tools before answering." : "",
-		requiredTool ? `You must call the ${JSON.stringify(requiredTool)} tool before answering.` : "",
+		request.toolChoice === "required" ? `You must call one of these request-scoped MCP tools before answering: ${toolNames}.` : "",
+		requiredTool ? `You must call the request-scoped MCP tool ${JSON.stringify(requiredTool)} before answering.` : "",
 		"",
 		JSON.stringify({ messages: request.messages })
 	].join("\n");
@@ -727,10 +755,23 @@ function sessionExtensions(extensions) {
 		}
 	};
 }
-function streamCompletion(turn, model) {
+function streamCompletion(turn, model, onCompatibilityDiagnostic) {
 	const encoder = new TextEncoder();
 	const id = `chatcmpl-${crypto.randomUUID()}`;
 	const created = Math.floor(Date.now() / 1e3);
+	const finishStream = (controller, reason, usage) => {
+		enqueueSse(controller, encoder, chatCompletionChunk(id, created, model, [{
+			delta: {},
+			finish_reason: reason,
+			index: 0
+		}]));
+		if (usage) enqueueSse(controller, encoder, {
+			...chatCompletionChunk(id, created, model, []),
+			usage: toOpenAIUsage(usage)
+		});
+		controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+		controller.close();
+	};
 	const body = new ReadableStream({
 		async cancel() {
 			await turn.cancel(/* @__PURE__ */ new Error("The OpenAI stream consumer cancelled the request."));
@@ -749,22 +790,27 @@ function streamCompletion(turn, model) {
 						}]));
 						continue;
 					}
-					if (output.type === "tool-call") throw new Error("Streaming tool calls are not supported.");
-					enqueueSse(controller, encoder, chatCompletionChunk(id, created, model, [{
-						delta: {},
-						finish_reason: finishReason(output.stopReason),
-						index: 0
-					}]));
-					if (output.usage) enqueueSse(controller, encoder, {
-						...chatCompletionChunk(id, created, model, []),
-						usage: {
-							completion_tokens: output.usage.outputTokens,
-							prompt_tokens: output.usage.inputTokens,
-							total_tokens: output.usage.totalTokens
-						}
-					});
-					controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-					controller.close();
+					if (output.type === "tool-call") {
+						deferToolCall(turn, output.call, onCompatibilityDiagnostic);
+						enqueueSse(controller, encoder, chatCompletionChunk(id, created, model, [{
+							delta: {
+								role: "assistant",
+								tool_calls: [{
+									function: {
+										arguments: output.call.arguments,
+										name: output.call.name
+									},
+									id: output.call.id,
+									index: 0,
+									type: "function"
+								}]
+							},
+							index: 0
+						}]));
+						finishStream(controller, "tool_calls", zeroUsage);
+						return;
+					}
+					finishStream(controller, finishReason(output.stopReason), output.usage);
 					return;
 				}
 			} catch (error) {
@@ -782,5 +828,12 @@ function toolsForChoice(tools, choice) {
 	if (typeof choice === "object") return tools.filter((tool) => tool.function.name === choice.function.name);
 	return tools;
 }
+function toOpenAIUsage(usage) {
+	return {
+		completion_tokens: usage.outputTokens,
+		prompt_tokens: usage.inputTokens,
+		total_tokens: usage.totalTokens
+	};
+}
 //#endregion
 export { createCommandModel, createGateway, startGateway };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/model-adapter-acp",
   "type": "module",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -21,7 +21,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@alint-js/core": "0.4.0"
+    "@alint-js/core": "0.5.0"
   },
   "scripts": {
     "build": "tsdown",