@bitkyc08/opencodex 2.7.33 → 2.7.34

package/src/adapters/kiro-tools.ts

@@ -1,8 +1,10 @@
 import type { OcxParsedRequest } from "../types";
 import { namespacedToolName } from "../types";
-import { kiroToolName } from "./kiro-wire";
+import { normalizeKiroModelId } from "../providers/kiro-models";
+import { createKiroToolNameRegistry, type KiroToolNameRegistry } from "./kiro-wire";
 
-const MAX_KIRO_TOOL_DESCRIPTION = 1024;
+const MAX_KIRO_TOOL_DESCRIPTION_UNVERIFIED = 1024;
+const MAX_KIRO_TOOL_DESCRIPTION_GPT_56_SOL = 9_216;
 
 // JSON Schema validation/annotation keywords that Kiro's runtimeservice tool-spec validator
 // rejects ("ValidationException: Invalid tool use format."). Codex's built-in tools omit these,
@@ -133,39 +135,47 @@ function ensureRootObjectType(schema: unknown): Record<string, unknown> {
   return merged;
 }
 
-export function convertKiroToolContext(parsed: OcxParsedRequest): { tools: unknown[]; systemAdditions: string[]; nameMap: Map<string, string> } {
+function toolDescriptionLimit(modelId: string): number {
+  return normalizeKiroModelId(modelId) === "gpt-5.6-sol"
+    ? MAX_KIRO_TOOL_DESCRIPTION_GPT_56_SOL
+    : MAX_KIRO_TOOL_DESCRIPTION_UNVERIFIED;
+}
+
+function truncateDescription(description: string, limit: number): string {
+  if (description.length <= limit) return description;
+  if (limit <= 1) return description.slice(0, limit);
+  return `${description.slice(0, limit - 1)}…`;
+}
+
+export function convertKiroToolContext(
+  parsed: OcxParsedRequest,
+  registry: KiroToolNameRegistry = createKiroToolNameRegistry(),
+): { tools: unknown[]; systemAdditions: string[]; nameMap: Map<string, string>; registry: KiroToolNameRegistry } {
   const tools = parsed.context.tools ?? [];
-  const systemAdditions: string[] = [];
-  // Maps the Kiro-safe toolSpecification.name back to the original wire name so the response parser
-  // can restore it (the bridge's toolNsMap is keyed by the original wire name). Only non-identity
-  // entries are stored.
-  const nameMap = new Map<string, string>();
+  const descriptionLimit = toolDescriptionLimit(parsed.modelId);
+  // Validate every listed name even when tool_choice:none emulates a tool-free turn.
+  for (const tool of tools) registry.alias(namespacedToolName(tool.namespace, tool.name));
+  const effectiveTools = parsed.options.toolChoice === "none" ? [] : tools;
   return {
-    tools: tools.map(t => {
+    tools: effectiveTools.map(t => {
       const description = t.description || `Tool: ${t.name}`;
       // Send the full namespaced wire name (e.g. mcp__chrome-devtools__navigate_page) so Kiro echoes
       // it back; the bridge's toolNsMap is keyed by this name and restores the MCP namespace Codex
       // routes by. Kiro's runtimeservice rejects names with spaces or >64 chars, so normalize to a
       // safe form and remember the mapping; the response parser restores the original wire name.
       const wireName = namespacedToolName(t.namespace, t.name);
-      const toolName = kiroToolName(wireName);
-      if (toolName !== wireName) nameMap.set(toolName, wireName);
-      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"));
-      }
+      const toolName = registry.alias(wireName);
       return {
         toolSpecification: {
           name: toolName,
-          description: kiroDescription,
+          description: truncateDescription(description, descriptionLimit),
           inputSchema: { json: ensureRootObjectType(sanitizeKiroSchema(t.parameters ?? {})) },
         },
       };
     }),
-    systemAdditions,
-    nameMap,
+    systemAdditions: [],
+    nameMap: registry.nameMap,
+    registry,
   };
 }
 

package/src/adapters/kiro-wire.ts

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { hostname, userInfo } from "node:os";
 import { normalizeKiroModelId } from "../providers/kiro-models";
 import type { OcxParsedRequest } from "../types";
+import { KIRO_COMPLETION_TOOL_NAME } from "./kiro-constants";
 
 let cachedFp: string | undefined;
 
@@ -70,6 +71,36 @@ export function kiroToolName(wireName: string, used?: Set<string>): string {
   }
 }
 
+export interface KiroToolNameRegistry {
+  alias(wireName: string): string;
+  restore(kiroName: string): string;
+  readonly nameMap: Map<string, string>;
+}
+
+/** One collision domain for advertised tools, replayed calls, and the private completion tool. */
+export function createKiroToolNameRegistry(): KiroToolNameRegistry {
+  const used = new Set<string>([KIRO_COMPLETION_TOOL_NAME]);
+  const wireToKiro = new Map<string, string>();
+  const nameMap = new Map<string, string>();
+  return {
+    alias(wireName: string): string {
+      if (wireName === KIRO_COMPLETION_TOOL_NAME) {
+        throw new Error(`Kiro reserves the tool name ${JSON.stringify(KIRO_COMPLETION_TOOL_NAME)}`);
+      }
+      const existing = wireToKiro.get(wireName);
+      if (existing) return existing;
+      const alias = kiroToolName(wireName, used);
+      wireToKiro.set(wireName, alias);
+      if (alias !== wireName) nameMap.set(alias, wireName);
+      return alias;
+    },
+    restore(kiroName: string): string {
+      return nameMap.get(kiroName) ?? kiroName;
+    },
+    nameMap,
+  };
+}
+
 export function fallbackToolUseId(): string {
   return `toolu_${randomUUID().slice(0, 8)}`;
 }
@@ -79,10 +110,20 @@ export function invocationId(): string {
 }
 
 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);
+  const remembered = parsed._providerContinuation?.kiro?.conversationId;
+  if (isValidKiroConversationId(remembered)) return remembered;
+  const conversationId = randomUUID();
+  parsed._providerContinuation = {
+    ...(parsed._providerContinuation ?? {}),
+    kiro: { ...(parsed._providerContinuation?.kiro ?? {}), conversationId },
+  };
+  return conversationId;
+}
+
+/** Kiro metadata is untrusted; keep only bounded, printable identifiers safe to persist/replay. */
+export function isValidKiroConversationId(value: unknown): value is string {
+  return typeof value === "string"
+    && value.length >= 1
+    && value.length <= 256
+    && /^[A-Za-z0-9._:-]+$/.test(value);
 }