@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
137 lines (128 loc) • 6.33 kB
text/typescript
import { hasRecordedTrailingDeliveredFinalAnswer } from "../../responses/turn-termination";
import type {
OcxAssistantMessage,
OcxMessage,
OcxParsedRequest,
} from "../../types";
import type { KiroImage } from "../kiro-images";
import type { KiroHistoryEntry, KiroToolResult, KiroToolUse } from "./wire";
/** Refuse request controls the Kiro wire cannot honour (forced tool choice, service tiers) before a request is built. */
export function validateKiroCapabilities(parsed: OcxParsedRequest): void {
const choice = parsed.options.toolChoice;
if (choice !== undefined && choice !== "auto" && choice !== "none") {
throw new Error("Kiro supports only automatic tool choice or tool_choice:none");
}
if (parsed.options.serviceTier !== undefined) {
throw new Error("Kiro does not support service tiers");
}
// Structured output is a real contract the wire has no response mode for, so it is not
// validated here: buildKiroPayload emulates it through the private structured-output tool
// (structured-output.ts), and the stream relays only JSON that tool or the bounded retry
// produced, or fails the turn. It used to be refused at this point, which kept the
// "no prose for a JSON caller" promise by failing every such turn instead.
//
// The rest of the Responses `text` object is not a contract at all. `text.verbosity` is a
// length preference and `text.format: {type:"text"}` is ordinary prose — the default output
// mode, which no capability flag governs and every correct client may send. Testing
// `_rawBody.text !== undefined` refused those turns for the mere PRESENCE of the key,
// the same mistake db040e70f removed one condition earlier where a permissive
// `parallel_tool_calls` hint was read as a requirement.
//
// Nothing needs stripping the way openai-responses strips a no-op verbosity:
// buildKiroPayload composes conversationState field by field from `parsed` and never
// spreads `_rawBody`, so a tolerated control is dropped by construction. The test
// asserts that absence so it stays true.
}
export type KiroTurn =
| {
kind: "user";
content: string;
images: KiroImage[];
toolResults: KiroToolResult[];
/**
* True only for the proxy-generated acknowledgement that follows a delivered final answer.
* A flag rather than a content comparison: a real user message may legitimately quote the
* same sentence, and treating that as internal state would strip its thinking tags and
* completion retry.
*/
answerDeliveredAck?: boolean;
}
| {
kind: "assistant";
content: string;
toolUses: KiroToolUse[];
redactedReasoning?: string;
/**
* True when this assistant turn was the DELIVERED final answer (Responses
* `phase: "final_answer"`). A trailing assistant turn normally means the model stopped
* mid-task and needs a continuation prompt, but a delivered final answer already ended its
* turn — prompting it again restarts finished work as if a goal were still open.
*/
finalAnswer?: boolean;
};
/**
* True when the LAST content-bearing message is an assistant final answer that closed its turn.
*
* Mirrors the turn-merge rule: a tool call in that message, or any later user/tool-result message,
* means work continued, so the turn is no longer terminal. Empty assistant messages are skipped
* rather than treated as continuation, since they carry no visible turn.
*/
export function hasTrailingDeliveredFinalAnswer(messages: readonly OcxMessage[], parsed?: OcxParsedRequest): boolean {
for (let i = messages.length - 1; i >= 0; i--) {
const msg = messages[i];
if (msg.role !== "assistant") return false;
const aMsg = msg as OcxAssistantMessage;
const hasToolCall = (aMsg.content ?? []).some(part => part.type === "toolCall");
if (hasToolCall) return false;
const hasText = (aMsg.content ?? []).some(part => part.type === "text" && part.text.trim());
if (!hasText) continue;
return aMsg.phase === "final_answer"
|| (parsed !== undefined && hasRecordedTrailingDeliveredFinalAnswer(parsed, messages));
}
return false;
}
export function appendTurnText(target: string, next: string): string {
if (!next) return target;
return target ? `${target}\n\n${next}` : next;
}
export function validateKiroConversationState(history: KiroHistoryEntry[], currentMessage: KiroHistoryEntry): void {
const entries = [...history, currentMessage];
const pendingToolUses = new Set<string>();
let previousRole: "user" | "assistant" | undefined;
for (const entry of entries) {
const user = entry.userInputMessage;
const assistant = entry.assistantResponseMessage;
if (Boolean(user) === Boolean(assistant)) {
throw new Error("Kiro conversation entries must contain exactly one message role");
}
const role = user ? "user" : "assistant";
if (role === previousRole) throw new Error("Kiro conversation roles must alternate");
previousRole = role;
if (user) {
const hasPayload = Boolean(user.content.trim())
|| Boolean(user.images?.length)
|| Boolean(user.userInputMessageContext?.toolResults?.length);
if (!hasPayload) throw new Error("Kiro user messages must not be empty");
for (const result of user.userInputMessageContext?.toolResults ?? []) {
if (!pendingToolUses.delete(result.toolUseId)) {
throw new Error(`Kiro tool result has no matching tool use ${JSON.stringify(result.toolUseId)}`);
}
if (!result.content.some(part => part.text.trim())) {
throw new Error(`Kiro tool result must not be empty ${JSON.stringify(result.toolUseId)}`);
}
}
continue;
}
const toolUses = assistant?.toolUses ?? [];
if (!assistant?.content.trim() && toolUses.length === 0) {
throw new Error("Kiro assistant messages must not be empty");
}
for (const toolUse of toolUses) {
if (pendingToolUses.has(toolUse.toolUseId)) {
throw new Error(`Kiro conversation contains duplicate tool use ${JSON.stringify(toolUse.toolUseId)}`);
}
pendingToolUses.add(toolUse.toolUseId);
}
}
if (pendingToolUses.size > 0) throw new Error("Kiro conversation contains an unanswered tool use");
}