feat(kiro): headless API-key auth + direct Claude/Kiro route
Adds long-lived API-key (ksk_) authentication for Kiro/AWS CodeWhisperer and a direct claude:kiro / kiro:claude translation route that avoids the lossy OpenAI two-hop pivot. - translator: claude-to-kiro request + kiro-to-claude response translators, registered on the exact source:target pair (direct route ahead of the OpenAI pivot in index.js). claude-to-kiro uses shared schema constants (ROLE/CLAUDE_BLOCK/DEFAULT_IMAGE_MIME) per app convention. - auth: POST /api/oauth/kiro/api-key imports + validates a key via ListAvailableProfiles, persists authMethod="api_key" (no refresh token). - executor: send tokentype: API_KEY header and try *.amazonaws.com hosts first for api-key creds; OAuth keeps kiro.dev first. - fix: never inject the default placeholder profileArn for api-key auth (CodeWhisperer 403s an ARN not owned by the key's account). - ui: API Key method in the Kiro connect modal; surface api-key accounts on the Quota Tracker and provider count. - stream: env-overridable TTFT vs stall timeouts + Kiro keepalive frame. - tests: claude-kiro-direct + kiro-profile-arn (11 tests). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
thienpv
463
open-sse/translator/request/claude-to-kiro.js
Normal file
463
open-sse/translator/request/claude-to-kiro.js
Normal file
@@ -0,0 +1,463 @@
|
||||
/**
|
||||
* Claude → Kiro Request Translator (DIRECT route, no OpenAI pivot)
|
||||
*
|
||||
* Converts Anthropic Messages API requests straight to Kiro / AWS
|
||||
* CodeWhisperer `GenerateAssistantResponse` payloads. This is the function the
|
||||
* direct `claude:kiro` route in ../index.js uses; it is NOT reached through the
|
||||
* claude→openai→kiro pivot.
|
||||
*
|
||||
* It reproduces the two 400-guards that live in openai-to-kiro.js so that a
|
||||
* Claude client which omits the `tools` array on a follow-up turn (typical
|
||||
* after client-side compaction) does not trip Kiro's schema validator and get
|
||||
* "Improperly formed request" (HTTP 400):
|
||||
*
|
||||
* 1. flattenClaudeToolInteractions — when the client sent NO tools, collapse
|
||||
* every tool_use / tool_result block to plain text so no structured tool
|
||||
* reference survives to trigger the "tools required" rule.
|
||||
* 2. reconcileOrphanedToolResults — when tools ARE present, fold any
|
||||
* tool_result whose tool_use_id has no matching tool_use back into the
|
||||
* user text instead of leaving a dangling structured reference.
|
||||
*
|
||||
* It also handles the 9router-synthetic `-agentic` / `-thinking` suffixes and
|
||||
* the `<thinking_mode>enabled</thinking_mode>` reasoning trigger, matching
|
||||
* buildKiroPayload.
|
||||
*/
|
||||
import { register } from "../index.js";
|
||||
import { FORMATS } from "../formats.js";
|
||||
import { v4 as uuidv4 } from "uuid";
|
||||
import {
|
||||
resolveKiroModel,
|
||||
isThinkingEnabled,
|
||||
buildThinkingSystemPrefix,
|
||||
KIRO_AGENTIC_SYSTEM_PROMPT,
|
||||
} from "../../config/kiroConstants.js";
|
||||
import { DEFAULT_IMAGE_MIME } from "../schema/index.js";
|
||||
import { ROLE, CLAUDE_BLOCK } from "../schema/index.js";
|
||||
|
||||
/** Stringify a tool_use input as a readable line. */
|
||||
function toolUseToText(name, input) {
|
||||
let argStr;
|
||||
try {
|
||||
argStr = typeof input === "string" ? input : JSON.stringify(input ?? {});
|
||||
} catch {
|
||||
argStr = "{}";
|
||||
}
|
||||
return `[Tool call: ${name || "unknown"}(${argStr})]`;
|
||||
}
|
||||
|
||||
/** Render a Claude tool_result block's content as a readable line. */
|
||||
function toolResultBlockToText(content) {
|
||||
let text = "";
|
||||
if (typeof content === "string") {
|
||||
text = content;
|
||||
} else if (Array.isArray(content)) {
|
||||
text = content
|
||||
.map((c) => (typeof c === "string" ? c : c?.text || ""))
|
||||
.filter(Boolean)
|
||||
.join("\n");
|
||||
} else if (content) {
|
||||
try {
|
||||
text = JSON.stringify(content);
|
||||
} catch {
|
||||
text = "";
|
||||
}
|
||||
}
|
||||
return `[Tool result: ${text}]`;
|
||||
}
|
||||
|
||||
/**
|
||||
* When the client sent no tools, rewrite every tool_use (assistant) and
|
||||
* tool_result (user) content block into plain text. Keeps text + images.
|
||||
* Returns a new messages array; never mutates the input.
|
||||
*/
|
||||
function flattenClaudeToolInteractions(messages) {
|
||||
const out = [];
|
||||
for (const msg of messages) {
|
||||
if (!msg) continue;
|
||||
|
||||
if (msg.role === ROLE.ASSISTANT && Array.isArray(msg.content)) {
|
||||
const parts = [];
|
||||
for (const block of msg.content) {
|
||||
if (block.type === CLAUDE_BLOCK.TEXT && block.text) {
|
||||
parts.push(block.text);
|
||||
} else if (block.type === CLAUDE_BLOCK.TOOL_USE) {
|
||||
parts.push(toolUseToText(block.name, block.input));
|
||||
}
|
||||
}
|
||||
out.push({ ...msg, content: parts.join("\n") });
|
||||
continue;
|
||||
}
|
||||
|
||||
if (msg.role === ROLE.USER && Array.isArray(msg.content)) {
|
||||
const newContent = msg.content.map((block) =>
|
||||
block.type === CLAUDE_BLOCK.TOOL_RESULT
|
||||
? { type: CLAUDE_BLOCK.TEXT, text: toolResultBlockToText(block.content) }
|
||||
: block
|
||||
);
|
||||
out.push({ ...msg, content: newContent });
|
||||
continue;
|
||||
}
|
||||
|
||||
out.push(msg);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert Claude messages to Kiro history + currentMessage.
|
||||
* Kiro requires alternating user/assistant turns; consecutive same-role
|
||||
* messages are merged.
|
||||
*/
|
||||
function convertClaudeMessagesToKiro(messages, tools, model) {
|
||||
const history = [];
|
||||
let currentMessage = null;
|
||||
|
||||
let pendingUserContent = [];
|
||||
let pendingAssistantContent = [];
|
||||
let pendingToolResults = [];
|
||||
let pendingImages = [];
|
||||
let currentRole = null;
|
||||
let toolsInjected = false;
|
||||
|
||||
const clientProvidedTools = Array.isArray(tools) && tools.length > 0;
|
||||
|
||||
const buildToolSpecs = () =>
|
||||
tools.map((t) => {
|
||||
const name = t.name;
|
||||
const description = t.description || `Tool: ${name}`;
|
||||
const schema = t.input_schema || {};
|
||||
const normalizedSchema =
|
||||
Object.keys(schema).length === 0
|
||||
? { type: "object", properties: {}, required: [] }
|
||||
: { ...schema, required: schema.required ?? [] };
|
||||
return {
|
||||
toolSpecification: {
|
||||
name,
|
||||
description,
|
||||
inputSchema: { json: normalizedSchema },
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
const flushPending = () => {
|
||||
if (currentRole === ROLE.USER) {
|
||||
const content = pendingUserContent.join("\n\n").trim() || "continue";
|
||||
const userMsg = { userInputMessage: { content, modelId: model } };
|
||||
|
||||
if (pendingImages.length > 0) {
|
||||
userMsg.userInputMessage.images = pendingImages;
|
||||
}
|
||||
if (pendingToolResults.length > 0) {
|
||||
userMsg.userInputMessage.userInputMessageContext = {
|
||||
toolResults: pendingToolResults,
|
||||
};
|
||||
}
|
||||
// Attach tools to the first user turn only.
|
||||
if (clientProvidedTools && !toolsInjected) {
|
||||
if (!userMsg.userInputMessage.userInputMessageContext) {
|
||||
userMsg.userInputMessage.userInputMessageContext = {};
|
||||
}
|
||||
userMsg.userInputMessage.userInputMessageContext.tools = buildToolSpecs();
|
||||
toolsInjected = true;
|
||||
}
|
||||
|
||||
history.push(userMsg);
|
||||
currentMessage = userMsg;
|
||||
pendingUserContent = [];
|
||||
pendingToolResults = [];
|
||||
pendingImages = [];
|
||||
} else if (currentRole === ROLE.ASSISTANT) {
|
||||
const content = pendingAssistantContent.join("\n\n").trim() || "...";
|
||||
history.push({ assistantResponseMessage: { content } });
|
||||
pendingAssistantContent = [];
|
||||
}
|
||||
};
|
||||
|
||||
for (const msg of messages) {
|
||||
const role = msg.role;
|
||||
if (role !== currentRole && currentRole !== null) flushPending();
|
||||
currentRole = role;
|
||||
|
||||
if (role === ROLE.USER) {
|
||||
if (typeof msg.content === "string") {
|
||||
pendingUserContent.push(msg.content);
|
||||
} else if (Array.isArray(msg.content)) {
|
||||
for (const block of msg.content) {
|
||||
if (block.type === CLAUDE_BLOCK.TEXT) {
|
||||
pendingUserContent.push(block.text);
|
||||
} else if (block.type === CLAUDE_BLOCK.IMAGE && block.source?.type === "base64") {
|
||||
const mediaType = block.source.media_type || DEFAULT_IMAGE_MIME;
|
||||
const format = mediaType.split("/")[1] || mediaType;
|
||||
pendingImages.push({ format, source: { bytes: block.source.data } });
|
||||
} else if (block.type === CLAUDE_BLOCK.TOOL_RESULT) {
|
||||
let resultContent = "";
|
||||
if (typeof block.content === "string") {
|
||||
resultContent = block.content;
|
||||
} else if (Array.isArray(block.content)) {
|
||||
resultContent =
|
||||
block.content
|
||||
.filter((c) => c.type === CLAUDE_BLOCK.TEXT)
|
||||
.map((c) => c.text)
|
||||
.join("\n") || JSON.stringify(block.content);
|
||||
} else if (block.content) {
|
||||
resultContent = JSON.stringify(block.content);
|
||||
}
|
||||
pendingToolResults.push({
|
||||
toolUseId: block.tool_use_id,
|
||||
status: "success",
|
||||
content: [{ text: resultContent }],
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (role === ROLE.ASSISTANT) {
|
||||
let textContent = "";
|
||||
const toolUses = [];
|
||||
if (typeof msg.content === "string") {
|
||||
textContent = msg.content;
|
||||
} else if (Array.isArray(msg.content)) {
|
||||
for (const block of msg.content) {
|
||||
if (block.type === CLAUDE_BLOCK.TEXT) {
|
||||
textContent += block.text;
|
||||
} else if (block.type === CLAUDE_BLOCK.TOOL_USE) {
|
||||
toolUses.push({
|
||||
toolUseId: block.id,
|
||||
name: block.name,
|
||||
input: block.input || {},
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
if (textContent) pendingAssistantContent.push(textContent);
|
||||
|
||||
if (toolUses.length > 0) {
|
||||
flushPending();
|
||||
const lastMsg = history[history.length - 1];
|
||||
if (lastMsg?.assistantResponseMessage) {
|
||||
lastMsg.assistantResponseMessage.toolUses = toolUses;
|
||||
}
|
||||
currentRole = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (currentRole !== null) flushPending();
|
||||
|
||||
// Pop the last user turn as currentMessage (skip trailing assistant turns).
|
||||
for (let i = history.length - 1; i >= 0; i--) {
|
||||
if (history[i].userInputMessage) {
|
||||
currentMessage = history.splice(i, 1)[0];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Grab tools from the first history user turn before cleanup strips them.
|
||||
const firstHistoryTools =
|
||||
history[0]?.userInputMessage?.userInputMessageContext?.tools;
|
||||
|
||||
history.forEach((item) => {
|
||||
if (item.userInputMessage?.userInputMessageContext?.tools) {
|
||||
delete item.userInputMessage.userInputMessageContext.tools;
|
||||
}
|
||||
if (
|
||||
item.userInputMessage?.userInputMessageContext &&
|
||||
Object.keys(item.userInputMessage.userInputMessageContext).length === 0
|
||||
) {
|
||||
delete item.userInputMessage.userInputMessageContext;
|
||||
}
|
||||
if (item.userInputMessage && !item.userInputMessage.modelId) {
|
||||
item.userInputMessage.modelId = model;
|
||||
}
|
||||
});
|
||||
|
||||
// Merge consecutive user turns (Kiro requires alternating roles).
|
||||
const mergedHistory = [];
|
||||
for (const current of history) {
|
||||
const prev = mergedHistory[mergedHistory.length - 1];
|
||||
if (current.userInputMessage && prev?.userInputMessage) {
|
||||
prev.userInputMessage.content += "\n\n" + current.userInputMessage.content;
|
||||
const prevCtx = prev.userInputMessage.userInputMessageContext;
|
||||
const curCtx = current.userInputMessage.userInputMessageContext;
|
||||
if (curCtx) {
|
||||
if (!prevCtx) {
|
||||
prev.userInputMessage.userInputMessageContext = curCtx;
|
||||
} else {
|
||||
if (curCtx.toolResults?.length > 0) {
|
||||
prevCtx.toolResults = [
|
||||
...(prevCtx.toolResults || []),
|
||||
...curCtx.toolResults,
|
||||
];
|
||||
}
|
||||
if (curCtx.tools?.length > 0) {
|
||||
prevCtx.tools = [...(prevCtx.tools || []), ...curCtx.tools];
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
mergedHistory.push(current);
|
||||
}
|
||||
}
|
||||
|
||||
if (!currentMessage) {
|
||||
currentMessage = { userInputMessage: { content: "", modelId: model } };
|
||||
}
|
||||
|
||||
// Inject tools into currentMessage after cleanup if not already present.
|
||||
if (
|
||||
firstHistoryTools?.length > 0 &&
|
||||
!currentMessage.userInputMessage.userInputMessageContext?.tools
|
||||
) {
|
||||
if (!currentMessage.userInputMessage.userInputMessageContext) {
|
||||
currentMessage.userInputMessage.userInputMessageContext = {};
|
||||
}
|
||||
currentMessage.userInputMessage.userInputMessageContext.tools =
|
||||
firstHistoryTools;
|
||||
}
|
||||
|
||||
return { history: mergedHistory, currentMessage };
|
||||
}
|
||||
|
||||
/**
|
||||
* Fold orphaned toolResults (those whose toolUseId has no matching toolUse in
|
||||
* any assistant turn) back into the user text, removing the dangling
|
||||
* structured reference that makes Kiro 400.
|
||||
*/
|
||||
function reconcileOrphanedToolResults(history, currentMessage) {
|
||||
const validIds = new Set();
|
||||
for (const h of history) {
|
||||
const arm = h.assistantResponseMessage;
|
||||
if (!arm) continue;
|
||||
for (const tu of arm.toolUses || []) {
|
||||
if (tu.toolUseId) validIds.add(tu.toolUseId);
|
||||
}
|
||||
}
|
||||
|
||||
const carriers = currentMessage ? [...history, currentMessage] : history;
|
||||
for (const item of carriers) {
|
||||
const uim = item.userInputMessage;
|
||||
const ctx = uim?.userInputMessageContext;
|
||||
if (!ctx?.toolResults?.length) continue;
|
||||
|
||||
const kept = [];
|
||||
const salvaged = [];
|
||||
for (const tr of ctx.toolResults) {
|
||||
if (validIds.has(tr.toolUseId)) {
|
||||
kept.push(tr);
|
||||
} else {
|
||||
const text = Array.isArray(tr.content)
|
||||
? tr.content.map((c) => c?.text || "").join("\n")
|
||||
: "";
|
||||
salvaged.push(`[Tool result: ${text}]`);
|
||||
}
|
||||
}
|
||||
|
||||
if (salvaged.length === 0) continue;
|
||||
|
||||
const extra = salvaged.join("\n");
|
||||
uim.content = uim.content ? `${uim.content}\n\n${extra}` : extra;
|
||||
ctx.toolResults = kept;
|
||||
if (kept.length === 0 && !ctx.tools?.length) {
|
||||
delete uim.userInputMessageContext;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a Kiro payload directly from a Claude Messages API request body.
|
||||
*/
|
||||
export function claudeToKiroRequest(model, body, stream, credentials) {
|
||||
let messages = Array.isArray(body.messages) ? body.messages : [];
|
||||
const tools = Array.isArray(body.tools) ? body.tools : [];
|
||||
const clientProvidedTools = tools.length > 0;
|
||||
const maxTokens = body.max_tokens || 32000;
|
||||
const temperature = body.temperature;
|
||||
const topP = body.top_p;
|
||||
|
||||
const {
|
||||
upstream: upstreamModel,
|
||||
agentic,
|
||||
thinking: modelImpliesThinking,
|
||||
} = resolveKiroModel(model);
|
||||
const thinkingEnabled =
|
||||
modelImpliesThinking || isThinkingEnabled(body, null, model);
|
||||
|
||||
// Guard 1: no client tools → flatten all tool interactions to text.
|
||||
if (!clientProvidedTools) {
|
||||
messages = flattenClaudeToolInteractions(messages);
|
||||
}
|
||||
|
||||
const { history, currentMessage } = convertClaudeMessagesToKiro(
|
||||
messages,
|
||||
tools,
|
||||
upstreamModel
|
||||
);
|
||||
|
||||
// Guard 2: tools present → reconcile dangling tool_results.
|
||||
if (clientProvidedTools) {
|
||||
reconcileOrphanedToolResults(history, currentMessage);
|
||||
}
|
||||
|
||||
const profileArn = credentials?.providerSpecificData?.profileArn || "";
|
||||
|
||||
let finalContent = currentMessage?.userInputMessage?.content || "";
|
||||
|
||||
// System prompt → prepend to the user content.
|
||||
if (body.system) {
|
||||
let systemText = "";
|
||||
if (typeof body.system === "string") {
|
||||
systemText = body.system;
|
||||
} else if (Array.isArray(body.system)) {
|
||||
systemText = body.system.map((s) => s.text || "").join("\n");
|
||||
}
|
||||
if (systemText) finalContent = `${systemText}\n\n${finalContent}`;
|
||||
}
|
||||
|
||||
// Prefix order: thinking_mode tag, timestamp marker, then agentic prompt.
|
||||
const timestamp = new Date().toISOString();
|
||||
const prefixParts = [];
|
||||
if (thinkingEnabled) prefixParts.push(buildThinkingSystemPrefix());
|
||||
prefixParts.push(`[Context: Current time is ${timestamp}]`);
|
||||
if (agentic) prefixParts.push(KIRO_AGENTIC_SYSTEM_PROMPT);
|
||||
finalContent = `${prefixParts.join("\n\n")}\n\n${finalContent}`;
|
||||
|
||||
const payload = {
|
||||
conversationState: {
|
||||
chatTriggerType: "MANUAL",
|
||||
conversationId: uuidv4(),
|
||||
currentMessage: {
|
||||
userInputMessage: {
|
||||
content: finalContent,
|
||||
modelId: upstreamModel,
|
||||
origin: "AI_EDITOR",
|
||||
...(currentMessage?.userInputMessage?.userInputMessageContext && {
|
||||
userInputMessageContext:
|
||||
currentMessage.userInputMessage.userInputMessageContext,
|
||||
}),
|
||||
...(currentMessage?.userInputMessage?.images && {
|
||||
images: currentMessage.userInputMessage.images,
|
||||
}),
|
||||
},
|
||||
},
|
||||
history,
|
||||
},
|
||||
};
|
||||
|
||||
if (profileArn) payload.profileArn = profileArn;
|
||||
|
||||
if (maxTokens || temperature !== undefined || topP !== undefined) {
|
||||
payload.inferenceConfig = {};
|
||||
if (maxTokens) payload.inferenceConfig.maxTokens = maxTokens;
|
||||
if (temperature !== undefined) payload.inferenceConfig.temperature = temperature;
|
||||
if (topP !== undefined) payload.inferenceConfig.topP = topP;
|
||||
}
|
||||
|
||||
// Non-enumerable hint so the executor can route the upstream model id.
|
||||
Object.defineProperty(payload, "_kiroUpstreamModel", {
|
||||
value: upstreamModel,
|
||||
enumerable: false,
|
||||
});
|
||||
|
||||
return payload;
|
||||
}
|
||||
|
||||
register(FORMATS.CLAUDE, FORMATS.KIRO, claudeToKiroRequest, null);
|
||||
Reference in New Issue
Block a user