ns-omp-provider-kiro 0.3.7 → 0.3.9

package/README.md

@@ -17,8 +17,8 @@ To build from a clone instead — for developing this package or
 `ns-kiro-core` before a release — install from the path:
 
 ```bash
-git clone git@github.com:ngosangns/ns-kiro-provider.git
-cd ns-kiro-provider && pnpm install && pnpm -r build
+git clone git@github.com:ngosangns/ns-bridge.git
+cd ns-bridge && pnpm install && pnpm -r build
 omp plugin install ./packages/omp-provider-kiro
 ```
 
@@ -59,4 +59,7 @@ upstream shows up without a release here.
 - `KIRO_DEBUG=1` writes a full request/response trace to
   `~/.ns-kiro-provider/logs/kiro-debug.log`, with credentials redacted.
 
-Part of [ns-kiro-provider](https://github.com/ngosangns/ns-kiro-provider).
+This is the recommended Kiro path in OMP. `ns-omp-provider` can also register a
+`kiro` provider, but leaves it off by default so the two never fight over the id.
+
+Part of [ns-bridge](https://github.com/ngosangns/ns-bridge).

package/dist/auth.d.ts

@@ -1,31 +1,8 @@
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai";
-/**
- * v0.1 establishes no browser flow of its own. Every interactive method Kiro
- * supports already lands a session in the kiro-cli store or the Kiro IDE token
- * file, so this reads one of those and refreshes it. The one credential with no
- * browser step — an API key — is accepted directly.
- */
+import { type ResolvedKiroRequestCredentials, resolveKiroRequestCredentials } from "ns-kiro-core";
+export type { ResolvedKiroRequestCredentials };
 export declare function loginKiro(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
 export declare function refreshKiroCredentials(credentials: OAuthCredentials): Promise<OAuthCredentials>;
 export declare function getKiroApiKey(credentials: OAuthCredentials): string;
-/** The token, region, and profile one request runs on. */
-export interface ResolvedKiroRequestCredentials {
-    accessToken: string;
-    region: string;
-    profileArn?: string;
-}
-/**
- * Decide which credential a request or catalog fetch runs on.
- *
- * The key OMP resolves for the provider is the session this package returned
- * from `/login kiro` — but it is also `$KIRO_API_KEY` verbatim when that
- * variable is unset, and Kiro answers a bogus bearer with a 403 the core then
- * has to recover from. So a host key is trusted only when it is recognizably a
- * Kiro credential; anything else defers to the store, which is where the
- * session actually lives.
- *
- * The stored record also carries the region and the profile ARN, and passing
- * the ARN skips the ListAvailableProfiles round trip that a social login cannot
- * answer anyway.
- */
-export declare function resolveRequestCredentials(hostKey: string | undefined): Promise<ResolvedKiroRequestCredentials>;
+/** See {@link resolveKiroRequestCredentials}: which credential one request or catalog fetch runs on. */
+export declare const resolveRequestCredentials: typeof resolveKiroRequestCredentials;

package/dist/index.js

@@ -2862,6 +2862,72 @@ function syntheticToolResultEntry(toolUseIds, modelId) {
   };
 }
 
+// ../kiro-core/dist/host-auth.js
+init_endpoints();
+init_oauth();
+var KIRO_NO_SESSION_MESSAGE = "No Kiro session found. Sign in with `kiro-cli login` (Builder ID, IAM Identity Center, Google, or GitHub), then run /login kiro again \u2014 or paste a Kiro API key below.";
+async function loginKiroFromSession(callbacks) {
+  callbacks.onProgress?.("Looking for an existing Kiro session\u2026");
+  const existing = await resolveKiroCredentials();
+  if (existing) {
+    callbacks.onProgress?.(`Using the ${existing.authMethod} session from kiro-cli.`);
+    return existing;
+  }
+  if (!callbacks.onPrompt)
+    throw new Error(KIRO_NO_SESSION_MESSAGE);
+  const apiKey = (await callbacks.onPrompt({
+    message: KIRO_NO_SESSION_MESSAGE,
+    placeholder: "ksk_\u2026",
+    allowEmpty: true,
+    secret: true
+  })).trim();
+  if (!apiKey)
+    throw new Error(KIRO_NO_SESSION_MESSAGE);
+  return loginKiroWithApiKey(apiKey, callbacks.onProgress);
+}
+async function resolveKiroRequestCredentials(hostKey) {
+  const stored = await resolveKiroCredentials();
+  const region = resolveApiRegion(stored?.region);
+  if (hostKey && (isApiKey(hostKey) || hostKey === stored?.access)) {
+    return { accessToken: hostKey, region, ...stored?.profileArn ? { profileArn: stored.profileArn } : {} };
+  }
+  if (stored) {
+    return {
+      accessToken: stored.access,
+      region,
+      ...stored.profileArn ? { profileArn: stored.profileArn } : {}
+    };
+  }
+  if (hostKey)
+    return { accessToken: hostKey, region };
+  throw new Error("Kiro credentials not set. Run `kiro-cli login`, or set KIRO_API_KEY to a `ksk_` API key.");
+}
+
+// ../kiro-core/dist/host-model.js
+init_models();
+function toKiroModelForHost(model, region) {
+  const known = getCachedModels(region).find((candidate) => candidate.id === model.id);
+  return {
+    ...known ?? {
+      id: model.id,
+      // No fallback to `model.id`: that dash-spelled local id is not a valid
+      // Kiro wire id. `""` is falsy, so `resolveKiroModel` runs its own
+      // cache/bootstrap/dot-normalize resolution instead of being
+      // short-circuited by a value that is really just `model.id` again.
+      kiroModelId: model.kiroModelId ?? "",
+      name: model.name,
+      reasoning: model.reasoning,
+      input: [...model.input],
+      cost: { ...model.cost },
+      contextWindow: model.contextWindow ?? 2e5,
+      maxTokens: model.maxTokens ?? 8192
+    },
+    region,
+    ...model.kiroProfileArn ? { profileArn: model.kiroProfileArn } : {},
+    ...model.additionalModelRequestFieldsSchema ? { additionalModelRequestFieldsSchema: model.additionalModelRequestFieldsSchema } : {}
+  };
+}
+
 // ../kiro-core/dist/invoke-tool-parser.js
 var INVOKE_OPEN_ANCHORED = /^<invoke name="([\w-]+)">/;
 var INVOKE_OPEN_SEARCH = "<invoke name=";
@@ -3566,12 +3632,177 @@ function countTokens(text) {
   return getEncoder().encode(text).length;
 }
 
+// ../kiro-core/dist/tool-name-aliases.js
+var TOOL_NAME_ALIASES = {
+  // read
+  read_file: "read",
+  readfile: "read",
+  fs_read: "read",
+  view_file: "read",
+  // write
+  write_file: "write",
+  writefile: "write",
+  fs_write: "write",
+  create_file: "write",
+  // edit
+  edit_file: "edit",
+  editfile: "edit",
+  str_replace: "edit",
+  str_replace_editor: "edit",
+  str_replace_based_edit_tool: "edit",
+  apply_patch: "edit",
+  // ls
+  list_directory: "ls",
+  list_dir: "ls",
+  list_files: "ls",
+  // find
+  find_files: "find",
+  file_search: "find"
+};
+function normalizeKiroToolName(name, declared) {
+  if (!declared || declared.size === 0 || declared.has(name))
+    return name;
+  const alias = TOOL_NAME_ALIASES[name.toLowerCase()];
+  return alias !== void 0 && declared.has(alias) ? alias : name;
+}
+
+// ../kiro-core/dist/tool-use-parser.js
+var TAG_NAMES = ["tool_use", "tool_call", "function_call", "tool"];
+var FENCE2 = "```";
+function nextTagBlock(text, from) {
+  let best = null;
+  for (const name of TAG_NAMES) {
+    const open = `<${name}>`;
+    const close = `</${name}>`;
+    const openStart = text.indexOf(open, from);
+    if (openStart < 0)
+      continue;
+    if (best && openStart >= best.openStart)
+      continue;
+    const bodyStart = openStart + open.length;
+    const closeIdx = text.indexOf(close, bodyStart);
+    if (closeIdx < 0)
+      continue;
+    best = { openStart, bodyStart, closeIdx, closeEnd: closeIdx + close.length };
+  }
+  return best;
+}
+function fencedRanges2(text) {
+  const ranges = [];
+  let searchFrom = 0;
+  while (true) {
+    const open = text.indexOf(FENCE2, searchFrom);
+    if (open < 0)
+      break;
+    const close = text.indexOf(FENCE2, open + FENCE2.length);
+    if (close < 0) {
+      ranges.push({ start: open, end: text.length });
+      break;
+    }
+    ranges.push({ start: open, end: close + FENCE2.length });
+    searchFrom = close + FENCE2.length;
+  }
+  return ranges;
+}
+function normalizeOne(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return null;
+  const record = value;
+  const rawName = record.tool_name ?? record.name;
+  if (typeof rawName !== "string" || rawName.length === 0)
+    return null;
+  const rawArgs = record.tool_input ?? record.input ?? record.arguments;
+  if (rawArgs === void 0) {
+    return { name: rawName, arguments: {} };
+  }
+  if (typeof rawArgs !== "object" || rawArgs === null || Array.isArray(rawArgs))
+    return null;
+  return { name: rawName, arguments: rawArgs };
+}
+function extractDescriptors(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const record = value;
+    const wrapped = record.tool_calls ?? record.calls;
+    if (Array.isArray(wrapped)) {
+      const out = [];
+      for (const entry of wrapped) {
+        const one = normalizeOne(entry);
+        if (one === null)
+          return [];
+        out.push(one);
+      }
+      return out;
+    }
+  }
+  const single = normalizeOne(value);
+  return single ? [single] : [];
+}
+function parseToolUseCalls(text) {
+  const toolCalls = [];
+  const removals = [];
+  const fences = fencedRanges2(text);
+  let cursor = 0;
+  while (cursor < text.length) {
+    const hit = nextTagBlock(text, cursor);
+    if (hit === null)
+      break;
+    const { openStart, bodyStart, closeIdx, closeEnd } = hit;
+    const containingFence = fences.find((range) => openStart >= range.start && openStart < range.end);
+    if (containingFence) {
+      cursor = containingFence.end;
+      continue;
+    }
+    const braceStart = text.indexOf("{", bodyStart);
+    if (braceStart < 0 || braceStart > closeIdx) {
+      cursor = closeEnd;
+      continue;
+    }
+    const braceEnd = findJsonEnd(text, braceStart);
+    if (braceEnd < 0 || braceEnd > closeIdx) {
+      cursor = closeEnd;
+      continue;
+    }
+    const beforeJson = text.substring(bodyStart, braceStart).trim();
+    const afterJson = text.substring(braceEnd + 1, closeIdx).trim();
+    if (beforeJson.length > 0 || afterJson.length > 0) {
+      cursor = closeEnd;
+      continue;
+    }
+    let descriptors = [];
+    try {
+      descriptors = extractDescriptors(JSON.parse(text.substring(braceStart, braceEnd + 1)));
+    } catch {
+      descriptors = [];
+    }
+    if (descriptors.length === 0) {
+      cursor = closeEnd;
+      continue;
+    }
+    for (const descriptor of descriptors) {
+      toolCalls.push({
+        toolUseId: crypto.randomUUID(),
+        name: descriptor.name,
+        arguments: descriptor.arguments
+      });
+    }
+    removals.push({ start: openStart, end: closeEnd });
+    cursor = closeEnd;
+  }
+  let cleanedText = text;
+  for (let i = removals.length - 1; i >= 0; i--) {
+    const { start, end } = removals[i];
+    cleanedText = cleanedText.substring(0, start) + cleanedText.substring(end);
+  }
+  return { toolCalls, cleanedText };
+}
+
 // ../kiro-core/dist/response-assembler.js
 var ECHO_NOISE_PATTERN = /^\s*(continue|\.+)\s*$/i;
 var KiroResponseAssembler = class {
   model;
   thinkingEnabled;
   toolNameAliases;
+  declaredToolNames;
   pending = [];
   blocks = new KiroBlockBuffer((event) => this.pending.push(event));
   usage = {
@@ -3581,7 +3812,6 @@ var KiroResponseAssembler = class {
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
   };
   totalContent = "";
-  lastContentData = "";
   usageEvent = null;
   meteringEvent = null;
   receivedContextUsage = false;
@@ -3594,18 +3824,19 @@ var KiroResponseAssembler = class {
   droppedToolCalls = [];
   currentToolCall = null;
   stopReason = "stop";
-  constructor(model, thinkingEnabled, toolNameAliases) {
+  constructor(model, thinkingEnabled, toolNameAliases, declaredToolNames) {
     this.model = model;
     this.thinkingEnabled = thinkingEnabled;
     this.toolNameAliases = toolNameAliases;
+    this.declaredToolNames = declaredToolNames;
   }
+  /** Wire name -> the name the host registered, then alias repair. */
   originalToolName(name) {
-    return this.toolNameAliases?.get(name) ?? name;
+    return normalizeKiroToolName(this.toolNameAliases?.get(name) ?? name, this.declaredToolNames);
   }
   /** Clear per-attempt state. Only block indexes are kept. */
   beginAttempt() {
     this.totalContent = "";
-    this.lastContentData = "";
     this.usageEvent = null;
     this.meteringEvent = null;
     this.receivedContextUsage = false;
@@ -3661,10 +3892,9 @@ var KiroResponseAssembler = class {
         break;
       }
       case "content": {
-        this.endNativeThinking();
-        if (event.data === this.lastContentData)
+        if (event.data === "")
           break;
-        this.lastContentData = event.data;
+        this.endNativeThinking();
         this.totalContent += event.data;
         if (this.thinkingParser) {
           this.thinkingParser.processChunk(event.data);
@@ -3703,6 +3933,14 @@ var KiroResponseAssembler = class {
       }
       case "usage": {
         this.usageEvent = { ...this.usageEvent ?? {}, ...event.data };
+        const pct = event.data.contextUsagePercentage;
+        if (pct !== void 0) {
+          if (this.usageEvent.inputTokens === void 0) {
+            this.usage.input = Math.round(pct / 100 * this.model.contextWindow);
+          }
+          this.usage.contextPercent = pct;
+          this.receivedContextUsage = true;
+        }
         if (debugEnabled())
           debugLog("response.usageRaw", payload);
         break;
@@ -3736,7 +3974,18 @@ var KiroResponseAssembler = class {
     this.stripEchoNoise();
     const responseText = this.textBlockIndex === null ? "" : this.blocks.getText(this.textBlockIndex);
     const hasText2 = responseText.length > 0;
-    this.stopReason = !this.receivedContextUsage && this.emittedToolCalls === 0 ? "length" : this.emittedToolCalls > 0 ? "toolUse" : "stop";
+    const wireStopReason = this.usageEvent?.rawStopReason;
+    switch (wireStopReason) {
+      case "MAX_TOKENS":
+        this.stopReason = "length";
+        break;
+      case "END_TURN":
+      case "TOOL_USE":
+        this.stopReason = this.emittedToolCalls > 0 ? "toolUse" : "stop";
+        break;
+      default:
+        this.stopReason = !this.receivedContextUsage && this.emittedToolCalls === 0 ? "length" : this.emittedToolCalls > 0 ? "toolUse" : "stop";
+    }
     return {
       responseText,
       hasText: hasText2,
@@ -3745,7 +3994,9 @@ var KiroResponseAssembler = class {
       isEchoLoop: hasText2 && !this.sawAnyToolCalls && ECHO_NOISE_PATTERN.test(responseText),
       isEmpty: !hasText2 && !this.sawAnyToolCalls,
       stopReason: this.stopReason,
-      droppedToolCalls: this.droppedToolCalls
+      droppedToolCalls: this.droppedToolCalls,
+      ...wireStopReason !== void 0 ? { wireStopReason } : {},
+      ...this.usageEvent?.stopDetails !== void 0 ? { wireStopDetails: this.usageEvent.stopDetails } : {}
     };
   }
   /** Drop an echo the caller decided not to retry, so it is not read as a continuation signal. */
@@ -3829,10 +4080,14 @@ var KiroResponseAssembler = class {
   }
   /**
    * Extract text-dialect tool calls from content when no native tool calls
-   * arrived. Two dialects are recovered at this seam:
+   * arrived. Three dialects are recovered at this seam:
    *   1. Kiro's own `[Called name with args: {...}]` bracket form.
    *   2. Anthropic's `<invoke name="..."><parameter .../></invoke>` XML form,
    *      which opus-class models emit as plain text at high context.
+   *   3. A JSON descriptor wrapped in `<tool_use>`, `<tool_call>`,
+   *      `<function_call>` or `<tool>` tags (upstream #163), spelled
+   *      `tool_name`/`tool_input`, `name`/`input` or `name`/`arguments`,
+   *      or wrapped in a `{"tool_calls": [...]}` array.
    * Without this, the turn ends `stop` with zero tool calls — the agent loop
    * sees a finished answer and an unattended session stalls with no error
    * recorded anywhere.
@@ -3859,6 +4114,11 @@ var KiroResponseAssembler = class {
       text = invokeResult.cleanedText;
       recovered.push(...invokeResult.toolCalls);
     }
+    const toolUseResult = parseToolUseCalls(text);
+    if (toolUseResult.toolCalls.length > 0) {
+      text = toolUseResult.cleanedText;
+      recovered.push(...toolUseResult.toolCalls);
+    }
     if (recovered.length === 0)
       return;
     this.blocks.setText(this.textBlockIndex, text);
@@ -4909,6 +5169,16 @@ function describeReturnedContent(kinds) {
 }
 var skipProfileResolutionForTests = false;
 var TEST_PROFILE_ARN = "arn:aws:codewhisperer:us-east-1:000000000000:profile/test";
+function throwOnTerminalWireStop(wireStopReason, stopDetails) {
+  switch (wireStopReason) {
+    case "MODEL_CONTEXT_WINDOW_EXCEEDED":
+      throw new Error("Kiro API error: context_length_exceeded (MODEL_CONTEXT_WINDOW_EXCEEDED)");
+    case "CONTENT_FILTERED":
+      throw new Error(`Kiro content filtered: ${clampForDiagnostic(redactSensitiveText(JSON.stringify(stopDetails ?? {})))}`);
+    case "PAUSE_TURN":
+      throw new Error("Kiro paused the turn (PAUSE_TURN); automatic continuation is not supported");
+  }
+}
 async function* streamKiro(request) {
   const { model, signal } = request;
   const initialAccessToken = request.accessToken;
@@ -4967,7 +5237,7 @@ async function* streamKiro(request) {
     systemPrompt = `<thinking_mode>enabled</thinking_mode><max_thinking_length>${budget}</max_thinking_length>${systemPrompt ? `
 ${systemPrompt}` : ""}`;
   }
-  const assembler = new KiroResponseAssembler(model, thinkingEnabled, kiroToolNameAliases(request.tools));
+  const assembler = new KiroResponseAssembler(model, thinkingEnabled, kiroToolNameAliases(request.tools), new Set((request.tools ?? []).map((tool) => String(tool.name))));
   const usageTracking = request.usageTracking ?? KIRO_USAGE_TRACKING_DISABLED;
   let retryCount = 0;
   const maxRetries = 3;
@@ -5151,6 +5421,7 @@ ${systemPrompt}` : ""}`;
       throw new Error(`Kiro API error: ${outcome.firstTokenTimedOut ? "first token" : "idle"} timeout after max retries`);
     }
     const summary = assembler.endTurn();
+    throwOnTerminalWireStop(summary.wireStopReason, summary.wireStopDetails);
     yield* assembler.takeEvents();
     const degenerate = summary.isEmpty || summary.isEchoLoop;
     if (summary.isEchoLoop)
@@ -5288,23 +5559,8 @@ async function fetchKiroUsage(credentials) {
 }
 
 // src/auth.ts
-var NO_SESSION_MESSAGE = "No Kiro session found. Sign in with `kiro-cli login` (Builder ID, IAM Identity Center, Google, or GitHub), then run /login kiro again \u2014 or paste a Kiro API key below.";
 async function loginKiro(callbacks) {
-  callbacks.onProgress?.("Looking for an existing Kiro session\u2026");
-  const existing = await resolveKiroCredentials();
-  if (existing) {
-    callbacks.onProgress?.(`Using the ${existing.authMethod} session from kiro-cli.`);
-    return existing;
-  }
-  if (!callbacks.onPrompt) throw new Error(NO_SESSION_MESSAGE);
-  const apiKey = (await callbacks.onPrompt({
-    message: NO_SESSION_MESSAGE,
-    placeholder: "ksk_\u2026",
-    allowEmpty: true,
-    secret: true
-  })).trim();
-  if (!apiKey) throw new Error(NO_SESSION_MESSAGE);
-  return await loginKiroWithApiKey(apiKey, callbacks.onProgress);
+  return await loginKiroFromSession(callbacks);
 }
 async function refreshKiroCredentials(credentials) {
   return await refreshKiroToken(credentials);
@@ -5312,22 +5568,7 @@ async function refreshKiroCredentials(credentials) {
 function getKiroApiKey(credentials) {
   return credentials.access;
 }
-async function resolveRequestCredentials(hostKey) {
-  const stored = await resolveKiroCredentials();
-  const region = resolveApiRegion(stored?.region);
-  if (hostKey && (isApiKey(hostKey) || hostKey === stored?.access)) {
-    return { accessToken: hostKey, region, ...stored?.profileArn ? { profileArn: stored.profileArn } : {} };
-  }
-  if (stored) {
-    return {
-      accessToken: stored.access,
-      region,
-      ...stored.profileArn ? { profileArn: stored.profileArn } : {}
-    };
-  }
-  if (hostKey) return { accessToken: hostKey, region };
-  throw new Error("Kiro credentials not set. Run `kiro-cli login`, or set KIRO_API_KEY to a `ksk_` API key.");
-}
+var resolveRequestCredentials = resolveKiroRequestCredentials;
 
 // src/models.ts
 function toOmpModelConfig(model) {
@@ -5359,22 +5600,81 @@ function kiroBaseUrl(region) {
 // src/stream.ts
 import * as PiAi from "@oh-my-pi/pi-ai";
 
-// src/messages.ts
+// ../bridge-core/dist/pi/transcript.js
+function isSystemMessage(message) {
+  return message?.role === "system";
+}
+function contentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => part && typeof part === "object" && part.type === "text" ? String(part.text ?? "") : "").filter((text) => text.length > 0).join("\n");
+}
+function getCurrentTools(messages) {
+  const tools = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (!isSystemMessage(message))
+      continue;
+    for (const tool of message.toolsRemoved ?? [])
+      tools.delete(tool.name);
+    for (const tool of message.toolsAdded ?? [])
+      tools.set(tool.name, tool);
+  }
+  return [...tools.values()];
+}
+function getCurrentSystemPrompt(messages) {
+  const content = [];
+  const sections = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (!isSystemMessage(message))
+      continue;
+    const text = contentText(message.content);
+    if (text.length > 0)
+      content.push(text);
+    for (const [name, value] of Object.entries(message.sections ?? {})) {
+      if (value === null)
+        sections.delete(name);
+      else
+        sections.set(name, value);
+    }
+  }
+  return [content.join("\n\n"), ...sections.values()].filter((part) => part.length > 0).join("\n\n");
+}
+
+// ../bridge-core/dist/pi/context.js
 function userContent(content) {
-  if (typeof content === "string") return content ? [{ type: "text", text: content }] : [];
+  if (typeof content === "string")
+    return content ? [{ type: "text", text: content }] : [];
+  if (!Array.isArray(content))
+    return [];
   const out = [];
   for (const block of content) {
-    if (block.type === "text") out.push({ type: "text", text: block.text });
-    else if (block.type === "image") {
-      const image = block;
-      out.push({ type: "image", data: image.data, mimeType: image.mimeType });
+    if (block?.type === "text" && typeof block.text === "string")
+      out.push({ type: "text", text: block.text });
+    else if (block?.type === "image" && typeof block.data === "string") {
+      out.push({ type: "image", data: block.data, mimeType: String(block.mimeType ?? "image/png") });
     }
   }
   return out;
 }
-function toKiroMessages(messages) {
+var STOP_REASONS = /* @__PURE__ */ new Set(["stop", "length", "toolUse", "error", "aborted"]);
+function parseArguments(value) {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value || "{}");
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return value && typeof value === "object" ? value : {};
+}
+function toBridgeMessages(messages) {
   const out = [];
   for (const message of messages) {
+    if (message.role === "system")
+      continue;
     if (message.role === "user" || message.role === "developer") {
       out.push({ role: "user", content: userContent(message.content) });
       continue;
@@ -5382,103 +5682,147 @@ function toKiroMessages(messages) {
     if (message.role === "toolResult") {
       out.push({
         role: "toolResult",
-        toolCallId: message.toolCallId,
-        toolName: message.toolName,
+        toolCallId: String(message.toolCallId ?? ""),
+        toolName: String(message.toolName ?? "tool"),
         content: userContent(message.content),
-        isError: message.isError
+        isError: message.isError === true
       });
       continue;
     }
+    if (message.role !== "assistant")
+      continue;
     const content = [];
-    for (const block of message.content) {
-      if (block.type === "text") content.push({ type: "text", text: block.text });
-      else if (block.type === "thinking") {
-        const thinking = block;
+    for (const block of Array.isArray(message.content) ? message.content : []) {
+      if (block?.type === "text" && typeof block.text === "string")
+        content.push({ type: "text", text: block.text });
+      else if (block?.type === "thinking" && typeof block.thinking === "string") {
         content.push({
           type: "thinking",
-          thinking: thinking.thinking,
-          ...thinking.thinkingSignature ? { thinkingSignature: thinking.thinkingSignature } : {}
+          thinking: block.thinking,
+          ...typeof block.thinkingSignature === "string" && block.thinkingSignature ? { thinkingSignature: block.thinkingSignature } : {}
         });
-      } else if (block.type === "toolCall") {
-        const call = block;
+      } else if (block?.type === "toolCall") {
         content.push({
           type: "toolCall",
-          id: call.id,
-          name: call.name,
-          arguments: typeof call.arguments === "string" ? JSON.parse(call.arguments) : call.arguments
+          id: String(block.id ?? ""),
+          name: String(block.name ?? ""),
+          arguments: parseArguments(block.arguments)
         });
       }
     }
-    out.push({ role: "assistant", content, stopReason: message.stopReason });
+    out.push({
+      role: "assistant",
+      content,
+      ...message.stopReason && STOP_REASONS.has(message.stopReason) ? { stopReason: message.stopReason } : {},
+      ...typeof message.responseId === "string" && message.responseId ? { responseId: message.responseId } : {}
+    });
   }
   return out;
 }
-function toKiroTools(tools) {
-  if (!tools?.length) return void 0;
+function toBridgeTools(tools) {
+  if (!tools?.length)
+    return void 0;
   return tools.map((tool) => ({
     name: tool.name,
-    description: tool.description,
-    parameters: tool.parameters
+    description: tool.description ?? "",
+    parameters: tool.parameters ?? { type: "object", properties: {} },
+    ...tool.strict !== void 0 ? { strict: tool.strict } : {}
   }));
 }
+function resolveSystemPrompt(context) {
+  const parts = [];
+  const declared = context.systemPrompt;
+  if (typeof declared === "string")
+    parts.push(declared);
+  else if (Array.isArray(declared))
+    parts.push(...declared.filter((part) => typeof part === "string"));
+  const fromTranscript = getCurrentSystemPrompt(context.messages);
+  if (fromTranscript)
+    parts.push(fromTranscript);
+  const joined = parts.filter((part) => part.trim().length > 0).join("\n\n");
+  return joined || void 0;
+}
+function resolveTools(context) {
+  if (context.tools?.length)
+    return [...context.tools];
+  return getCurrentTools(context.messages);
+}
+function toBridgeContext(context) {
+  const systemPrompt = resolveSystemPrompt(context);
+  const tools = toBridgeTools(resolveTools(context));
+  return {
+    ...systemPrompt ? { systemPrompt } : {},
+    messages: toBridgeMessages(context.messages),
+    ...tools ? { tools } : {}
+  };
+}
 
-// src/stream.ts
-function newEventStream() {
-  const runtime = PiAi;
-  if (typeof runtime.AssistantMessageEventStream === "function") return new runtime.AssistantMessageEventStream();
-  if (typeof runtime.createAssistantMessageEventStream === "function") {
-    return runtime.createAssistantMessageEventStream();
+// ../bridge-core/dist/types.js
+var BRIDGE_EFFORT_ORDER = ["minimal", "low", "medium", "high", "xhigh", "max"];
+
+// ../bridge-core/dist/pi/models.js
+var EFFORTS = new Set(BRIDGE_EFFORT_ORDER);
+function toBridgeEffort(reasoning) {
+  return typeof reasoning === "string" && EFFORTS.has(reasoning) ? reasoning : void 0;
+}
+
+// ../bridge-core/dist/errors.js
+var SECRET_PATTERNS = [
+  /(authorization\s*[:=]\s*)(bearer\s+)?[^\s,;"']+/gi,
+  /(bearer\s+)[A-Za-z0-9._~+/=$-]{12,}/gi,
+  /\b(ksk_|devin-session-token\$|sk-)[A-Za-z0-9._~+/=$-]{8,}/g
+];
+function formatErrorMessage(error2) {
+  let text = error2 instanceof Error ? error2.message || error2.name : String(error2);
+  for (const pattern of SECRET_PATTERNS) {
+    text = text.replace(pattern, (_match, prefix) => `${prefix ?? ""}[redacted]`);
   }
-  throw new Error("This omp build exposes no AssistantMessageEventStream; omp-provider-kiro needs omp >= 18.1.");
+  return text;
 }
-var ZERO_USAGE = () => ({
-  input: 0,
-  output: 0,
-  cacheRead: 0,
-  cacheWrite: 0,
-  totalTokens: 0,
-  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
-});
-function toKiroModel(model, region) {
-  const known = getCachedModels(region).find((candidate) => candidate.id === model.id);
+
+// ../bridge-core/dist/pi/stream.js
+function zeroPiUsage() {
   return {
-    ...known ?? {
-      id: model.id,
-      // No fallback to `model.id`: that dash-spelled local id is not a valid
-      // Kiro wire id. Falls back to `""` rather than `model.id` — falsy, so
-      // `resolveKiroModel`'s `if (exactKiroModelId) return exactKiroModelId`
-      // treats it as no override and runs its own cache/bootstrap/dot-normalize
-      // resolution instead of being short-circuited by a value that is really
-      // just `model.id` again.
-      kiroModelId: model.kiroModelId ?? "",
-      name: model.name,
-      reasoning: model.reasoning,
-      input: [...model.input],
-      cost: { ...model.cost },
-      contextWindow: model.contextWindow ?? 2e5,
-      maxTokens: model.maxTokens ?? 8192
-    },
-    region,
-    ...model.kiroProfileArn ? { profileArn: model.kiroProfileArn } : {},
-    ...model.additionalModelRequestFieldsSchema ? { additionalModelRequestFieldsSchema: model.additionalModelRequestFieldsSchema } : {}
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
   };
 }
-function streamKiroForOmp(model, context, options) {
-  const stream = newEventStream();
+function applyBridgeUsage(target, usage) {
+  target.input = usage.input;
+  target.output = usage.output;
+  target.totalTokens = usage.totalTokens;
+  target.cacheRead = usage.cacheRead ?? 0;
+  target.cacheWrite = usage.cacheWrite ?? 0;
+  target.cost = { ...usage.cost };
+  if (usage.contextPercent !== void 0)
+    target.contextPercent = usage.contextPercent;
+  if (usage.credits !== void 0)
+    target.credits = usage.credits;
+  if (usage.creditUnit !== void 0)
+    target.creditUnit = usage.creditUnit;
+  if (usage.cacheEstimated !== void 0)
+    target.cacheEstimated = usage.cacheEstimated;
+}
+function streamToPi(options) {
+  const stream = options.createStream();
+  const formatError = options.formatError ?? formatErrorMessage;
+  const discardOnReset = options.discardOnReset ?? true;
+  const output = {
+    role: "assistant",
+    content: [],
+    api: options.model.api,
+    provider: options.model.provider,
+    model: options.model.id,
+    usage: zeroPiUsage(),
+    stopReason: "stop",
+    timestamp: Date.now()
+  };
   (async () => {
-    const output = {
-      role: "assistant",
-      content: [],
-      api: model.api,
-      provider: model.provider,
-      model: model.id,
-      usage: ZERO_USAGE(),
-      stopReason: "stop",
-      timestamp: Date.now()
-    };
     try {
-      const hostKey = typeof options?.apiKey === "string" ? options.apiKey : void 0;
-      const credentials = await resolveRequestCredentials(hostKey);
       let indexes = /* @__PURE__ */ new Map();
       const open = (coreIndex, block) => {
         const contentIndex = output.content.length;
@@ -5487,121 +5831,114 @@ function streamKiroForOmp(model, context, options) {
         return contentIndex;
       };
       const at = (coreIndex) => indexes.get(coreIndex);
-      const region = model.kiroRegion ?? getKiroRegionFromEndpoint(model.baseUrl) ?? credentials.region;
-      for await (const event of streamKiro({
-        model: toKiroModel(model, region),
-        messages: toKiroMessages(context.messages),
-        systemPrompt: context.systemPrompt?.join("\n\n"),
-        tools: toKiroTools(context.tools),
-        effort: options?.reasoning,
-        accessToken: credentials.accessToken,
-        sessionId: options?.sessionId,
-        signal: options?.signal,
-        profileArn: model.kiroProfileArn ?? credentials.profileArn,
-        // OMP renders from `partial`, so discarding blocks is a matter of
-        // truncating the array the renderer already reads.
-        canDiscardEmittedBlocks: true
-      })) {
+      let started = false;
+      const start = () => {
+        if (started)
+          return;
+        started = true;
+        stream.push({ type: "start", partial: output });
+      };
+      for await (const event of await options.events()) {
         switch (event.type) {
           case "start":
-            stream.push({ type: "start", partial: output });
+            start();
             break;
           case "reset":
-            output.content = [];
-            indexes = /* @__PURE__ */ new Map();
+            if (discardOnReset) {
+              output.content = [];
+              indexes = /* @__PURE__ */ new Map();
+            }
             break;
           case "text_start": {
+            start();
             const contentIndex = open(event.index, { type: "text", text: "" });
             stream.push({ type: "text_start", contentIndex, partial: output });
             break;
           }
           case "text_delta": {
             const contentIndex = at(event.index);
-            if (contentIndex === void 0) break;
+            if (contentIndex === void 0)
+              break;
             output.content[contentIndex].text += event.delta;
             stream.push({ type: "text_delta", contentIndex, delta: event.delta, partial: output });
             break;
           }
           case "text_end": {
             const contentIndex = at(event.index);
-            if (contentIndex === void 0) break;
+            if (contentIndex === void 0)
+              break;
             output.content[contentIndex].text = event.text;
             stream.push({ type: "text_end", contentIndex, content: event.text, partial: output });
             break;
           }
           case "thinking_start": {
+            start();
             const contentIndex = open(event.index, { type: "thinking", thinking: "" });
             stream.push({ type: "thinking_start", contentIndex, partial: output });
             break;
           }
           case "thinking_delta": {
             const contentIndex = at(event.index);
-            if (contentIndex === void 0) break;
+            if (contentIndex === void 0)
+              break;
             output.content[contentIndex].thinking += event.delta;
             stream.push({ type: "thinking_delta", contentIndex, delta: event.delta, partial: output });
             break;
           }
           case "thinking_end": {
             const contentIndex = at(event.index);
-            if (contentIndex === void 0) break;
+            if (contentIndex === void 0)
+              break;
             const block = output.content[contentIndex];
             block.thinking = event.thinking;
-            if (event.signature) block.thinkingSignature = event.signature;
+            if (event.signature)
+              block.thinkingSignature = event.signature;
             stream.push({ type: "thinking_end", contentIndex, content: event.thinking, partial: output });
             break;
           }
           case "tool_call_start": {
-            const toolCall = { type: "toolCall", id: event.id, name: event.name, arguments: {} };
-            const contentIndex = open(event.index, toolCall);
+            start();
+            const contentIndex = open(event.index, { type: "toolCall", id: event.id, name: event.name, arguments: {} });
             stream.push({ type: "toolcall_start", contentIndex, partial: output });
             break;
           }
           case "tool_call_delta": {
             const contentIndex = at(event.index);
-            if (contentIndex === void 0) break;
+            if (contentIndex === void 0)
+              break;
             stream.push({ type: "toolcall_delta", contentIndex, delta: event.argumentsDelta, partial: output });
             break;
           }
           case "tool_call_end": {
             const contentIndex = at(event.index);
-            if (contentIndex === void 0) break;
+            if (contentIndex === void 0)
+              break;
             const toolCall = output.content[contentIndex];
+            toolCall.name = event.name;
             toolCall.arguments = event.arguments;
             stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
             break;
           }
-          case "usage": {
-            output.usage.input = event.usage.input;
-            output.usage.output = event.usage.output;
-            output.usage.totalTokens = event.usage.totalTokens;
-            output.usage.cacheRead = event.usage.cacheRead ?? 0;
-            output.usage.cacheWrite = event.usage.cacheWrite ?? 0;
-            output.usage.cost = { ...event.usage.cost };
-            if (event.usage.contextPercent !== void 0) {
-              output.usage.contextPercent = event.usage.contextPercent;
-            }
-            if (event.usage.credits !== void 0) {
-              output.usage.credits = event.usage.credits;
-            }
-            if (event.usage.creditUnit !== void 0) {
-              output.usage.creditUnit = event.usage.creditUnit;
-            }
-            if (event.usage.cacheEstimated !== void 0) {
-              output.usage.cacheEstimated = event.usage.cacheEstimated;
-            }
+          case "usage":
+            applyBridgeUsage(output.usage, event.usage);
             break;
-          }
           case "done":
+            start();
             output.stopReason = event.stopReason;
-            if (event.errorMessage) output.errorMessage = event.errorMessage;
+            if (event.responseId)
+              output.responseId = event.responseId;
+            if (event.upstreamModel && event.upstreamModel !== output.model)
+              output.responseModel = event.upstreamModel;
+            if (event.errorMessage)
+              output.errorMessage = event.errorMessage;
             stream.push({ type: "done", reason: event.stopReason, message: output });
             break;
         }
       }
       stream.end();
     } catch (error2) {
-      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-      output.errorMessage = formatSafeError(error2);
+      output.stopReason = options.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = formatError(error2);
       stream.push({ type: "error", reason: output.stopReason, error: output });
       stream.end();
     }
@@ -5614,6 +5951,48 @@ function streamKiroForOmp(model, context, options) {
   return stream;
 }
 
+// src/stream.ts
+function newEventStream() {
+  const runtime = PiAi;
+  if (typeof runtime.AssistantMessageEventStream === "function") return new runtime.AssistantMessageEventStream();
+  if (typeof runtime.createAssistantMessageEventStream === "function") {
+    return runtime.createAssistantMessageEventStream();
+  }
+  throw new Error("This omp build exposes no AssistantMessageEventStream; omp-provider-kiro needs omp >= 18.1.");
+}
+function toKiroModel(model, region) {
+  return toKiroModelForHost(model, region);
+}
+function streamKiroForOmp(model, context, options) {
+  return streamToPi({
+    model,
+    createStream: newEventStream,
+    signal: options?.signal,
+    formatError: formatSafeError,
+    // OMP renders from `partial`, so discarding blocks is a matter of
+    // truncating the array the renderer already reads.
+    discardOnReset: true,
+    events: async () => {
+      const hostKey = typeof options?.apiKey === "string" ? options.apiKey : void 0;
+      const credentials = await resolveRequestCredentials(hostKey);
+      const region = model.kiroRegion ?? getKiroRegionFromEndpoint(model.baseUrl) ?? credentials.region;
+      const neutral = toBridgeContext(context);
+      return streamKiro({
+        model: toKiroModel(model, region),
+        messages: neutral.messages,
+        systemPrompt: neutral.systemPrompt,
+        tools: neutral.tools,
+        effort: toBridgeEffort(options?.reasoning),
+        accessToken: credentials.accessToken,
+        sessionId: options?.sessionId,
+        signal: options?.signal,
+        profileArn: model.kiroProfileArn ?? credentials.profileArn,
+        canDiscardEmittedBlocks: true
+      });
+    }
+  });
+}
+
 // src/usage.ts
 function toUsageUnit(unit) {
   switch (unit?.toLowerCase()) {
@@ -5755,8 +6134,8 @@ export {
   index_default as default,
   kiroUsageProvider,
   streamKiroForOmp,
-  toKiroMessages,
-  toKiroTools,
+  toBridgeMessages as toKiroMessages,
+  toBridgeTools as toKiroTools,
   toOmpModelConfig,
   toUsageReport
 };

package/dist/messages.d.ts

@@ -1,10 +1 @@
-import type { Message, Tool } from "@oh-my-pi/pi-ai";
-import type { KiroMessage, KiroTool } from "ns-kiro-core";
-/**
- * OMP carries block kinds this provider has no wire slot for — redacted
- * thinking, Anthropic fallback markers, verbatim server-tool blocks. They are
- * dropped rather than flattened into text: Kiro would read invented markup back
- * as the model's own prior speech.
- */
-export declare function toKiroMessages(messages: Message[]): KiroMessage[];
-export declare function toKiroTools(tools: Tool[] | undefined): KiroTool[] | undefined;
+export { toBridgeMessages as toKiroMessages, toBridgeTools as toKiroTools } from "ns-bridge-core/pi";

package/dist/stream.d.ts

@@ -7,18 +7,6 @@ export type KiroBackedModel = Model<Api> & {
     kiroProfileArn?: string;
     additionalModelRequestFieldsSchema?: Record<string, unknown>;
 };
-/**
- * Rebuild the core's model descriptor from what OMP hands back at request time.
- *
- * OMP's registry keeps its own `Model`, built from the config this provider
- * registered, so the catalog entry is looked up again here rather than carried
- * through: the ladder and the request-fields schema decide effort mapping, and
- * a request must use the same ones the catalog advertised.
- *
- * Looks up the region's authenticated cache, not the static bootstrap list:
- * models discovered only through the authenticated catalog (no bootstrap
- * entry) would otherwise miss this lookup and fall through to guessing a wire
- * id from the dash-spelled local `id`, which Kiro rejects as `INVALID_MODEL_ID`.
- */
+/** Rebuild the core's model descriptor from what OMP hands back at request time (see kiro-core). */
 export declare function toKiroModel(model: KiroBackedModel, region: string): KiroModel;
 export declare function streamKiroForOmp(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ns-omp-provider-kiro",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "OMP (oh-my-pi) provider plugin: adds Kiro (AWS CodeWhisperer/Q) models via your kiro-cli login",
   "type": "module",
   "main": "./dist/index.js",
@@ -8,7 +8,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ngosangns/ns-kiro-provider.git",
+    "url": "git+https://github.com/ngosangns/ns-bridge.git",
     "directory": "packages/omp-provider-kiro"
   },
   "keywords": [
@@ -37,7 +37,7 @@
     "README.md"
   ],
   "dependencies": {
-    "ns-kiro-core": "0.3.7"
+    "ns-kiro-core": "0.3.9"
   },
   "peerDependencies": {
     "@oh-my-pi/pi-ai": ">=18.2.0",
@@ -54,7 +54,8 @@
   "devDependencies": {
     "@oh-my-pi/pi-ai": "18.2.7",
     "@oh-my-pi/pi-coding-agent": "18.2.7",
-    "@types/node": "^22.20.4"
+    "@types/node": "^22.20.4",
+    "ns-bridge-core": "0.1.0"
   },
   "scripts": {
     "build": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --banner:js=\"import{createRequire as __kiroCreateRequire}from'node:module';const require=__kiroCreateRequire(import.meta.url);\" --external:@oh-my-pi/pi-ai --external:@oh-my-pi/pi-catalog --external:@oh-my-pi/pi-coding-agent --external:@oh-my-pi/pi-tui && tsc -p tsconfig.json --emitDeclarationOnly",