npm - @bitkyc08/opencodex - Versions diffs - 2.6.1 → 2.6.2 - Mend

@bitkyc08/opencodex 2.6.1 → 2.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

package/README.md +8 -0
package/bin/ocx.mjs +41 -9
package/gui/dist/assets/index-LK87QnT7.js +9 -0
package/gui/dist/index.html +1 -1
package/package.json +1 -1
package/src/abort.ts +22 -0
package/src/adapters/base.ts +17 -4
package/src/adapters/kiro-errors.ts +101 -0
package/src/adapters/kiro-events.ts +48 -0
package/src/adapters/kiro-images.ts +33 -0
package/src/adapters/kiro-retry.ts +95 -0
package/src/adapters/kiro-thinking.ts +82 -0
package/src/adapters/kiro-tool-fallback.ts +36 -0
package/src/adapters/kiro-tools.ts +44 -0
package/src/adapters/kiro-truncation.ts +33 -0
package/src/adapters/kiro-wire.ts +51 -0
package/src/adapters/kiro.ts +527 -0
package/src/adapters/openai-chat.ts +10 -1
package/src/bridge.ts +1 -1
package/src/cli.ts +25 -3
package/src/codex-catalog.ts +97 -13
package/src/codex-inject.ts +18 -0
package/src/config.ts +52 -0
package/src/crash-guard.ts +197 -9
package/src/debug.ts +11 -0
package/src/errors.ts +39 -3
package/src/lib/eventstream-decoder.ts +244 -0
package/src/lib/token-estimate.ts +43 -0
package/src/oauth/anthropic.ts +1 -1
package/src/oauth/index.ts +53 -6
package/src/oauth/kiro-credentials.ts +256 -0
package/src/oauth/kiro.ts +164 -0
package/src/oauth/local-token-detect.ts +2 -1
package/src/oauth/store.ts +36 -3
package/src/oauth/types.ts +3 -0
package/src/oauth/xai.ts +1 -1
package/src/providers/kiro-models.ts +55 -0
package/src/providers/registry.ts +15 -0
package/src/redact.ts +71 -0
package/src/server.ts +40 -22
package/src/sidecar-tracker.ts +49 -0
package/src/types.ts +3 -0
package/src/usage-debug.ts +7 -4
package/src/usage-log.ts +41 -3
package/src/vision/describe.ts +11 -2
package/src/web-search/executor.ts +10 -2
package/src/web-search/loop.ts +27 -7
package/gui/dist/assets/index-BmHrbTmO.js +0 -9

package/gui/dist/index.html CHANGED Viewed

@@ -16,7 +16,7 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-BmHrbTmO.js"></script>
+    <script type="module" crossorigin src="/assets/index-LK87QnT7.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BwvDb198.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@bitkyc08/opencodex",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "Universal provider proxy for OpenAI Codex — use any LLM with Codex CLI/App/SDK",
   "type": "module",
   "main": "./bin/package-main.mjs",

package/src/abort.ts CHANGED Viewed

@@ -27,3 +27,25 @@ export function signalWithTimeout(timeoutMs: number, parent?: AbortSignal): Link
     },
   };
 }
+/**
+ * Bind a response body's lifetime to an abort signal.
+ *
+ * Bun's HTTP client, when a `fetch(..., { signal })` is aborted AFTER the response resolved, tears
+ * down the response body stream and rejects any in-flight internal read. If our code hasn't attached
+ * a reader yet (e.g. the abort lands between `await fetch()` and the decoder's first read), that
+ * rejection is orphaned off the awaited path and Bun reports it as
+ * `unhandledRejection: TypeError: null is not an object` (native-only stack) — uncatchable by any
+ * caller try/catch. Proactively cancelling the body on abort makes US the consumer that settles it,
+ * so the rejection is absorbed. Returns a cleanup to detach the listener on the normal path.
+ */
+export function cancelBodyOnAbort(body: ReadableStream<Uint8Array> | null, signal?: AbortSignal): () => void {
+  if (!body || !signal) return () => {};
+  const onAbort = () => { void body.cancel().catch(() => {}); };
+  if (signal.aborted) {
+    onAbort();
+    return () => {};
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => signal.removeEventListener("abort", onAbort);
+}

package/src/adapters/base.ts CHANGED Viewed

@@ -8,13 +8,26 @@ export interface IncomingMeta {
 export interface ProviderAdapter {
   name: string;
-  buildRequest(parsed: OcxParsedRequest, incoming?: IncomingMeta): {
+  buildRequest(parsed: OcxParsedRequest, incoming?: IncomingMeta): AdapterRequest;
+  fetchResponse?(request: AdapterRequest, ctx?: AdapterFetchContext): Promise<Response>;
+  parseStream(response: Response): AsyncGenerator<AdapterEvent>;
+  parseResponse?(response: Response): Promise<AdapterEvent[]>;
+}
+export interface AdapterRequest {
     url: string;
     method: string;
     headers: Record<string, string>;
     body: string;
-  };
+    usageLog?: {
+      inputTokens?: number;
+      estimated?: boolean;
+    };
+}
-  parseStream(response: Response): AsyncGenerator<AdapterEvent>;
-  parseResponse?(response: Response): Promise<AdapterEvent[]>;
+export interface AdapterFetchContext {
+  abortSignal?: AbortSignal;
+  timeoutMs?: number;
 }

package/src/adapters/kiro-errors.ts ADDED Viewed

@@ -0,0 +1,101 @@
+import { redactSecretString } from "../redact";
+const ABSOLUTE_PATH_PATTERN = /(?:\/Users\/[^ "';,]+|\/home\/[^ "';,]+|[A-Za-z]:\\Users\\[^ "';,]+)/g;
+const DETAIL_KEYS = ["__type", "code", "error", "name", "message", "Message", "errorMessage"];
+function sanitizeKiroErrorText(value: string): string {
+  return redactSecretString(value).replace(ABSOLUTE_PATH_PATTERN, "[REDACTED_PATH]");
+}
+function safeString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function headerValue(headers: Headers | Record<string, unknown>, name: string): string | undefined {
+  if (headers instanceof Headers) return name.startsWith(":") ? undefined : safeString(headers.get(name));
+  return safeString(headers[name]) || safeString(headers[name.toLowerCase()]);
+}
+function payloadDetails(payloadText: string): string[] {
+  const trimmed = payloadText.trim();
+  if (!trimmed) return [];
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return [trimmed];
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const obj = parsed as Record<string, unknown>;
+      return DETAIL_KEYS.map(key => safeString(obj[key])).filter((v): v is string => !!v);
+    }
+    if (typeof parsed === "string" && parsed.trim()) return [parsed.trim()];
+  } catch {
+    return [];
+  }
+  return [];
+}
+function classifyKiroText(status: number | undefined, text: string): string {
+  const lower = text.toLowerCase();
+  const rateQuota = /requests?\s+per\s+(?:min|minute|second)|rpm|tpm/.test(lower);
+  const quotaExhausted =
+    lower.includes("insufficient_quota") ||
+    lower.includes("quota exhausted") ||
+    lower.includes("account quota exceeded") ||
+    lower.includes("monthly quota exceeded") ||
+    lower.includes("daily quota exceeded") ||
+    lower.includes("exceeded your current quota");
+  if (quotaExhausted && !rateQuota) return "Kiro quota exhausted";
+  if (
+    status === 429 ||
+    lower.includes("throttlingexception") ||
+    lower.includes("too many requests") ||
+    lower.includes("rate limited") ||
+    lower.includes("rate limit")
+  ) return "Kiro rate limit exceeded";
+  if (
+    status === 401 ||
+    status === 403 ||
+    lower.includes("accessdenied") ||
+    lower.includes("access denied") ||
+    lower.includes("unauthorized") ||
+    lower.includes("unrecognizedclient") ||
+    lower.includes("expiredtoken") ||
+    lower.includes("expired token") ||
+    lower.includes("invalid token") ||
+    lower.includes("authentication")
+  ) return "Kiro authentication failed";
+  if (
+    status === 503 ||
+    lower.includes("overloaded") ||
+    lower.includes("server is busy") ||
+    lower.includes("temporarily unavailable")
+  ) return "Kiro server overloaded";
+  if (
+    status === 400 ||
+    lower.includes("validationexception") ||
+    lower.includes("invalid request") ||
+    lower.includes("profile arn") ||
+    lower.includes("model unavailable") ||
+    lower.includes("model not found") ||
+    lower.includes("unsupported model") ||
+    lower.includes("region") ||
+    lower.includes("schema") ||
+    lower.includes("malformed")
+  ) return "Kiro invalid request";
+  return "Kiro upstream error";
+}
+function normalizedKiroErrorMessage(headers: Headers | Record<string, unknown>, payloadText: string, status?: number): string {
+  const headerType = headerValue(headers, ":exception-type") || headerValue(headers, ":error-type");
+  const parts = [headerType, ...payloadDetails(payloadText)].filter((part): part is string => !!part);
+  const detail = parts.length > 0 ? sanitizeKiroErrorText(parts.join(": ")).slice(0, 500) : status ? `HTTP ${status}` : "";
+  const prefix = classifyKiroText(status, [detail, headerType].filter(Boolean).join(" "));
+  return detail ? `${prefix}: ${detail}` : prefix;
+}
+export function safeKiroErrorMessage(headers: Record<string, unknown>, payloadText: string): string {
+  return normalizedKiroErrorMessage(headers, payloadText);
+}
+export function safeKiroHttpErrorMessage(status: number, headers: Headers | Record<string, unknown>, payloadText: string): string {
+  return normalizedKiroErrorMessage(headers, payloadText, status);
+}

package/src/adapters/kiro-events.ts ADDED Viewed

@@ -0,0 +1,48 @@
+import { kiroTruncationReason } from "./kiro-truncation";
+export interface ParsedKiroEvent {
+  type: "content" | "tool_start" | "tool_input" | "tool_stop" | "truncation" | "usage" | "context_usage";
+  data?: string;
+  contextUsagePercentage?: number;
+  usage?: unknown;
+  name?: string;
+  toolUseId?: string;
+  input?: string;
+}
+export function parseKiroEvent(payload: Uint8Array): ParsedKiroEvent | null {
+  let text: string;
+  try {
+    text = new TextDecoder().decode(payload).trim();
+  } catch {
+    return null;
+  }
+  if (!text.startsWith("{")) return null;
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  const truncationReason = kiroTruncationReason(parsed);
+  if (truncationReason) return { type: "truncation", data: truncationReason };
+  if ("usage" in parsed) return { type: "usage", usage: parsed.usage };
+  if (typeof parsed.contextUsagePercentage === "number" && Number.isFinite(parsed.contextUsagePercentage)) {
+    return { type: "context_usage", contextUsagePercentage: parsed.contextUsagePercentage };
+  }
+  if ("content" in parsed && typeof parsed.content === "string") return { type: "content", data: parsed.content };
+  const toolUseId = typeof parsed.toolUseId === "string" ? parsed.toolUseId : undefined;
+  const name = typeof parsed.name === "string" ? parsed.name : undefined;
+  if (parsed.stop === true) return { type: "tool_stop", toolUseId };
+  if ("input" in parsed) {
+    const input =
+      typeof parsed.input === "object" && parsed.input !== null
+        ? JSON.stringify(parsed.input)
+        : typeof parsed.input === "string"
+          ? parsed.input
+          : "";
+    return { type: "tool_input", input, name, toolUseId };
+  }
+  if (name !== undefined) return { type: "tool_start", name, toolUseId };
+  return null;
+}

package/src/adapters/kiro-images.ts ADDED Viewed

@@ -0,0 +1,33 @@
+import type { OcxContentPart } from "../types";
+// CodeWhisperer native image part (matches Kiro IDE wire format): the base64 bytes live directly in
+// userInputMessage.images, NOT in userInputMessageContext. Verified against kiro-gateway.
+export interface KiroImage {
+  format: string; // "jpeg" | "png" | "webp" | "gif" — derived from the media subtype
+  source: { bytes: string }; // pure base64, no "data:...;base64," prefix
+}
+// Codex sends each image as a `data:` URL (base64) or a remote https URL. Only data URLs can be
+// inlined as bytes here; remote URLs are not fetchable at request-build time.
+function parseDataUrlImage(imageUrl: string): KiroImage | undefined {
+  if (!imageUrl.startsWith("data:")) return undefined;
+  const comma = imageUrl.indexOf(",");
+  if (comma === -1) return undefined;
+  const header = imageUrl.slice(5, comma);
+  const bytes = imageUrl.slice(comma + 1);
+  if (!bytes) return undefined;
+  const mediaType = header.split(";")[0] || "image/jpeg";
+  const format = mediaType.includes("/") ? mediaType.split("/")[1] : mediaType;
+  return { format: format || "jpeg", source: { bytes } };
+}
+export function extractKiroImages(content: string | OcxContentPart[]): KiroImage[] {
+  if (typeof content === "string") return [];
+  const out: KiroImage[] = [];
+  for (const p of content) {
+    if (p.type !== "image") continue;
+    const img = parseDataUrlImage(p.imageUrl);
+    if (img) out.push(img);
+  }
+  return out;
+}

package/src/adapters/kiro-retry.ts ADDED Viewed

@@ -0,0 +1,95 @@
+import type { AdapterFetchContext, AdapterRequest } from "./base";
+import { safeKiroHttpErrorMessage } from "./kiro-errors";
+const KIRO_RETRY_ATTEMPTS = 3;
+const KIRO_RETRY_BASE_MS = 250;
+const KIRO_RETRY_MAX_MS = 2_000;
+function retryableKiroStatus(status: number): boolean {
+  return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+function retryAfterMs(headers: Headers): number | undefined {
+  const raw = headers.get("retry-after")?.trim();
+  if (!raw) return undefined;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);
+  const dateMs = Date.parse(raw);
+  if (!Number.isFinite(dateMs)) return undefined;
+  return Math.max(0, dateMs - Date.now());
+}
+function retryDelayMs(attempt: number, headers?: Headers): number {
+  const retryAfter = headers ? retryAfterMs(headers) : undefined;
+  if (retryAfter !== undefined) return Math.min(retryAfter, KIRO_RETRY_MAX_MS);
+  const exp = Math.min(KIRO_RETRY_BASE_MS * (2 ** attempt), KIRO_RETRY_MAX_MS);
+  return Math.floor(exp * (0.8 + Math.random() * 0.4));
+}
+function abortError(signal?: AbortSignal): unknown {
+  return signal?.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+async function sleepWithAbort(ms: number, signal?: AbortSignal): Promise<void> {
+  if (ms <= 0) return;
+  if (signal?.aborted) throw abortError(signal);
+  await new Promise<void>((resolve, reject) => {
+    let timer: ReturnType<typeof setTimeout>;
+    const cleanup = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(abortError(signal));
+    };
+    timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function signalWithAttemptTimeout(parent: AbortSignal | undefined, timeoutMs: number): AbortSignal {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return parent ? AbortSignal.any([parent, timeout]) : timeout;
+}
+async function normalizeFinalKiroHttpError(res: Response): Promise<Response> {
+  if (res.ok) return res;
+  const payloadText = await res.clone().text().catch(() => "");
+  const headers = new Headers(res.headers);
+  headers.delete("content-encoding");
+  headers.delete("content-length");
+  return new Response(safeKiroHttpErrorMessage(res.status, res.headers, payloadText), {
+    status: res.status,
+    statusText: res.statusText,
+    headers,
+  });
+}
+export async function fetchKiroWithRetry(request: AdapterRequest, ctx: AdapterFetchContext = {}): Promise<Response> {
+  const timeoutMs = ctx.timeoutMs ?? 30_000;
+  let lastError: unknown;
+  for (let attempt = 0; attempt < KIRO_RETRY_ATTEMPTS; attempt++) {
+    if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
+    try {
+      const res = await fetch(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: signalWithAttemptTimeout(ctx.abortSignal, timeoutMs),
+      });
+      if (!retryableKiroStatus(res.status) || attempt === KIRO_RETRY_ATTEMPTS - 1) return normalizeFinalKiroHttpError(res);
+      await res.body?.cancel().catch(() => {});
+      await sleepWithAbort(retryDelayMs(attempt, res.headers), ctx.abortSignal);
+    } catch (err) {
+      if (ctx.abortSignal?.aborted) throw err;
+      lastError = err;
+      if (attempt === KIRO_RETRY_ATTEMPTS - 1) throw err;
+      await sleepWithAbort(retryDelayMs(attempt), ctx.abortSignal);
+    }
+  }
+  throw lastError ?? new Error("Kiro fetch failed");
+}

package/src/adapters/kiro-thinking.ts ADDED Viewed

@@ -0,0 +1,82 @@
+import type { AdapterEvent } from "../types";
+type ThinkingTag = "<thinking>" | "<think>" | "<reasoning>";
+type ParserState = "pre" | "thinking" | "streaming";
+const OPEN_TAGS: ThinkingTag[] = ["<thinking>", "<think>", "<reasoning>"];
+const MAX_OPEN_TAG = Math.max(...OPEN_TAGS.map(t => t.length));
+const MAX_CLOSE_TAG = Math.max(...OPEN_TAGS.map(t => `</${t.slice(1)}`.length));
+function closeTagFor(openTag: ThinkingTag): string {
+  return `</${openTag.slice(1)}`;
+}
+function isPossibleOpenTagPrefix(text: string): boolean {
+  return OPEN_TAGS.some(tag => tag.startsWith(text) && text.length < tag.length);
+}
+export class KiroThinkingParser {
+  private state: ParserState = "pre";
+  private preBuffer = "";
+  private thinkingBuffer = "";
+  private closeTag = "";
+  feed(text: string): AdapterEvent[] {
+    if (!text) return [];
+    if (this.state === "streaming") return [{ type: "text_delta", text }];
+    if (this.state === "thinking") {
+      this.thinkingBuffer += text;
+      return this.drainThinking();
+    }
+    this.preBuffer += text;
+    const stripped = this.preBuffer.trimStart();
+    const openTag = OPEN_TAGS.find(tag => stripped.startsWith(tag));
+    if (openTag) {
+      this.state = "thinking";
+      this.closeTag = closeTagFor(openTag);
+      this.thinkingBuffer = stripped.slice(openTag.length);
+      this.preBuffer = "";
+      return this.drainThinking();
+    }
+    if (stripped.length <= MAX_OPEN_TAG && isPossibleOpenTagPrefix(stripped)) return [];
+    this.state = "streaming";
+    const out = this.preBuffer;
+    this.preBuffer = "";
+    return out ? [{ type: "text_delta", text: out }] : [];
+  }
+  flush(): AdapterEvent[] {
+    if (this.state === "thinking") {
+      const out = this.thinkingBuffer;
+      this.thinkingBuffer = "";
+      this.state = "streaming";
+      return out ? [{ type: "reasoning_raw_delta", text: out }] : [];
+    }
+    if (this.preBuffer) {
+      const out = this.preBuffer;
+      this.preBuffer = "";
+      this.state = "streaming";
+      return [{ type: "text_delta", text: out }];
+    }
+    return [];
+  }
+  private drainThinking(): AdapterEvent[] {
+    const close = this.closeTag;
+    const idx = this.thinkingBuffer.indexOf(close);
+    if (idx >= 0) {
+      const thinking = this.thinkingBuffer.slice(0, idx);
+      const after = this.thinkingBuffer.slice(idx + close.length).trimStart();
+      this.thinkingBuffer = "";
+      this.state = "streaming";
+      const events: AdapterEvent[] = [];
+      if (thinking) events.push({ type: "reasoning_raw_delta", text: thinking });
+      if (after) events.push({ type: "text_delta", text: after });
+      return events;
+    }
+    if (this.thinkingBuffer.length <= MAX_CLOSE_TAG) return [];
+    const send = this.thinkingBuffer.slice(0, -MAX_CLOSE_TAG);
+    this.thinkingBuffer = this.thinkingBuffer.slice(-MAX_CLOSE_TAG);
+    return send ? [{ type: "reasoning_raw_delta", text: send }] : [];
+  }
+}

package/src/adapters/kiro-tool-fallback.ts ADDED Viewed

@@ -0,0 +1,36 @@
+import type { OcxContentPart, OcxToolCall, OcxToolResultMessage } from "../types";
+import { normalizeToolId } from "./kiro-wire";
+function stringifyValue(value: unknown): string {
+  try { return JSON.stringify(value); } catch { return String(value); }
+}
+function contentText(content: string | OcxContentPart[]): string {
+  if (typeof content === "string") return content;
+  return content
+    .map(part => {
+      if (part.type === "text") return part.text;
+      if (part.type === "image") return `[image:${part.detail ?? "auto"}]`;
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+export function appendFallbackText(base: string, fallback: string): string {
+  return [base, fallback].filter(Boolean).join("\n\n");
+}
+export function toolCallFallbackText(toolCall: OcxToolCall): string {
+  return [
+    `Tool call fallback (${toolCall.name}, id ${normalizeToolId(toolCall.id)}):`,
+    stringifyValue(toolCall.arguments ?? {}),
+  ].join("\n");
+}
+export function toolResultFallbackText(toolResult: OcxToolResultMessage): string {
+  return [
+    `Tool result fallback (${toolResult.toolName}, id ${normalizeToolId(toolResult.toolCallId)}, ${toolResult.isError ? "error" : "success"}):`,
+    contentText(toolResult.content) || "(empty)",
+  ].join("\n");
+}

package/src/adapters/kiro-tools.ts ADDED Viewed

@@ -0,0 +1,44 @@
+import type { OcxParsedRequest } from "../types";
+const MAX_KIRO_TOOL_DESCRIPTION = 1024;
+function sanitizeKiroSchema(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sanitizeKiroSchema);
+  if (!value || typeof value !== "object") return value;
+  const out: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
+    if (key === "additionalProperties") continue;
+    if (key === "required" && Array.isArray(child) && child.length === 0) continue;
+    out[key] = sanitizeKiroSchema(child);
+  }
+  return out;
+}
+export function convertKiroToolContext(parsed: OcxParsedRequest): { tools: unknown[]; systemAdditions: string[] } {
+  const tools = parsed.context.tools ?? [];
+  const systemAdditions: string[] = [];
+  return {
+    tools: tools.map(t => {
+      const description = t.description || `Tool: ${t.name}`;
+      const toolName = t.name.slice(0, 64);
+      const kiroDescription = description.length > MAX_KIRO_TOOL_DESCRIPTION
+        ? `Tool documentation moved to the system prompt: ${toolName}.`
+        : description;
+      if (description.length > MAX_KIRO_TOOL_DESCRIPTION) {
+        systemAdditions.push([`### Tool documentation: ${toolName}`, description].join("\n"));
+      }
+      return {
+        toolSpecification: {
+          name: toolName,
+          description: kiroDescription,
+          inputSchema: { json: sanitizeKiroSchema(t.parameters ?? {}) as Record<string, unknown> },
+        },
+      };
+    }),
+    systemAdditions,
+  };
+}
+export function convertKiroTools(parsed: OcxParsedRequest): unknown[] {
+  return convertKiroToolContext(parsed).tools;
+}

package/src/adapters/kiro-truncation.ts ADDED Viewed

@@ -0,0 +1,33 @@
+import { redactSecretString } from "../redact";
+const REASON_KEYS = ["finish_reason", "finishReason", "stop_reason", "stopReason", "completionReason", "reason"];
+const TRUNCATION_PATTERN = /length|max[_-]?tokens?|truncat|incomplete|context_length/i;
+function safeString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+export function kiroTruncationReason(parsed: Record<string, unknown>): string | undefined {
+  if (parsed.truncated === true) return "truncated";
+  for (const key of REASON_KEYS) {
+    const value = safeString(parsed[key]);
+    if (value && TRUNCATION_PATTERN.test(value)) return value;
+  }
+  return undefined;
+}
+export function isCompleteKiroToolInput(input: string): boolean {
+  const trimmed = input.trim();
+  if (!trimmed) return true;
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    return parsed !== null && typeof parsed === "object";
+  } catch {
+    return false;
+  }
+}
+export function kiroTruncationErrorMessage(reason?: string): string {
+  const suffix = reason ? ` (${redactSecretString(reason).slice(0, 160)})` : "";
+  return `Kiro response truncated upstream before the tool call completed${suffix}`;
+}

package/src/adapters/kiro-wire.ts ADDED Viewed

@@ -0,0 +1,51 @@
+import { createHash, randomUUID } from "node:crypto";
+import { hostname, userInfo } from "node:os";
+import { normalizeKiroModelId } from "../providers/kiro-models";
+import type { OcxParsedRequest } from "../types";
+let cachedFp: string | undefined;
+export function fingerprint(): string {
+  if (cachedFp) return cachedFp;
+  try {
+    cachedFp = createHash("sha256").update(`${hostname()}-${userInfo().username}-kiro-ocx`).digest("hex");
+  } catch {
+    cachedFp = createHash("sha256").update("default-kiro-ocx").digest("hex");
+  }
+  return cachedFp;
+}
+export function osTag(): string {
+  const p = process.platform;
+  if (p === "darwin") return "macos#24.0.0";
+  if (p === "win32") return "win32#10.0.26100";
+  return "linux#6.8.0";
+}
+/** Registry/user model id -> CodeWhisperer model id. */
+export function mapModelId(id: string): string {
+  return normalizeKiroModelId(id);
+}
+/** CodeWhisperer toolUseId constraint: ^[a-zA-Z0-9_-]{1,64}$ */
+export function normalizeToolId(id: string): string {
+  const s = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return s.length > 64 ? s.slice(0, 64) : s;
+}
+export function fallbackToolUseId(): string {
+  return `toolu_${randomUUID().slice(0, 8)}`;
+}
+export function invocationId(): string {
+  return randomUUID();
+}
+export function stableConversationId(parsed: OcxParsedRequest): string {
+  const msgs = parsed.context.messages;
+  if (!msgs || msgs.length === 0) return randomUUID().slice(0, 16);
+  const key = (msgs.length <= 3 ? msgs : [...msgs.slice(0, 3), msgs[msgs.length - 1]])
+    .map(m => `${m.role}:${JSON.stringify((m as { content?: unknown }).content ?? "").slice(0, 100)}`)
+    .join("|");
+  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+}