@iislee/opencodex 2.11.0

package/src/adapters/run-turn-queue.ts

@@ -0,0 +1,114 @@
+import type { AdapterEvent } from "../types";
+
+type QueueReader = (result: IteratorResult<AdapterEvent>) => void;
+
+export const PREFLIGHT_HEARTBEAT_RETAIN_LIMIT = 16;
+
+export interface AdapterEventQueue {
+  push(event: AdapterEvent): void;
+  close(): void;
+  stream(): AsyncIterable<AdapterEvent>;
+  collect(): Promise<AdapterEvent[]>;
+}
+
+export interface AdapterEventPreflight {
+  stream: AsyncIterable<AdapterEvent>;
+  error?: Extract<AdapterEvent, { type: "error" }>;
+  empty: boolean;
+}
+
+async function* replay(
+  buffered: readonly AdapterEvent[],
+  iterator: AsyncIterator<AdapterEvent>,
+): AsyncGenerator<AdapterEvent> {
+  try {
+    for (const event of buffered) yield event;
+    while (true) {
+      const next = await iterator.next();
+      if (next.done) return;
+      yield next.value;
+    }
+  } finally {
+    await iterator.return?.();
+  }
+}
+
+export async function preflightAdapterEvents(
+  source: AsyncIterable<AdapterEvent>,
+): Promise<AdapterEventPreflight> {
+  const iterator = source[Symbol.asyncIterator]();
+  const buffered: AdapterEvent[] = [];
+  while (true) {
+    const next = await iterator.next();
+    if (next.done) return { stream: replay(buffered, iterator), empty: true };
+    if (next.value.type === "heartbeat") {
+      buffered.push(next.value);
+      if (buffered.length > PREFLIGHT_HEARTBEAT_RETAIN_LIMIT) buffered.shift();
+      continue;
+    }
+    buffered.push(next.value);
+    if (next.value.type === "error") {
+      await iterator.return?.();
+      return { stream: replay(buffered, iterator), error: next.value, empty: false };
+    }
+    return { stream: replay(buffered, iterator), empty: false };
+  }
+}
+
+export function createAdapterEventQueue(opts?: {
+  maxBacklog?: number;
+  onBacklogExceeded?: () => void;
+}): AdapterEventQueue {
+  const queued: AdapterEvent[] = [];
+  const readers: QueueReader[] = [];
+  const maxBacklog = opts?.maxBacklog ?? 1_024;
+  let closed = false;
+
+  const push = (event: AdapterEvent): void => {
+    if (closed) return;
+    const reader = readers.shift();
+    if (reader) {
+      reader({ done: false, value: event });
+      return;
+    }
+    if (queued.length >= maxBacklog) {
+      opts?.onBacklogExceeded?.();
+      queued.push({ type: "error", message: "consumer backlog exceeded — turn aborted" });
+      close();
+      return;
+    }
+    queued.push(event);
+  };
+
+  const close = (): void => {
+    if (closed) return;
+    closed = true;
+    while (readers.length > 0) {
+      readers.shift()?.({ done: true, value: undefined as never });
+    }
+  };
+
+  async function* stream(): AsyncIterable<AdapterEvent> {
+    while (true) {
+      const next = queued.shift();
+      if (next) {
+        yield next;
+        continue;
+      }
+      if (closed) return;
+      const result = await new Promise<IteratorResult<AdapterEvent>>(resolve => {
+        readers.push(resolve);
+      });
+      if (result.done) return;
+      yield result.value;
+    }
+  }
+
+  const collect = async (): Promise<AdapterEvent[]> => {
+    const events: AdapterEvent[] = [];
+    for await (const event of stream()) events.push(event);
+    return events;
+  };
+
+  return { push, close, stream, collect };
+}

package/src/adapters/tool-catalog-nudge.ts

@@ -0,0 +1,71 @@
+import {
+  isAllowedToolChoice,
+  namespacedToolName,
+  toolAllowedByChoice,
+  toolChoiceAliases,
+  type OcxRequestOptions,
+  type OcxTool,
+  type OcxProviderConfig,
+} from "../types";
+
+const NEIGHBOR_AGENT_TOOL_NAMES = ["Read", "Grep", "Glob", "Bash", "LS", "apply_patch"] as const;
+
+function quoteNames(names: readonly string[]): string {
+  return names.map(name => `\`${name}\``).join(", ");
+}
+
+function uniqueNames(names: readonly string[]): string[] {
+  return [...new Set(names.filter(name => name.trim().length > 0))];
+}
+
+function toolChoiceAllows(tool: Pick<OcxTool, "namespace" | "name">, toolChoice: OcxRequestOptions["toolChoice"] | undefined): boolean {
+  if (!toolChoice || toolChoice === "auto" || toolChoice === "required") return true;
+  if (toolChoice === "none") return false;
+  if (isAllowedToolChoice(toolChoice)) return toolAllowedByChoice(tool, new Set(toolChoice.allowedTools));
+  return toolChoiceAliases(tool).includes(toolChoice.name);
+}
+
+function isOpenAIOrChatGPTHost(hostname: string): boolean {
+  return hostname === "openai.com"
+    || hostname.endsWith(".openai.com")
+    || hostname === "chatgpt.com"
+    || hostname.endsWith(".chatgpt.com");
+}
+
+export function shouldInjectNonOpenAIToolCatalogNudge(provider: Pick<OcxProviderConfig, "baseUrl">): boolean {
+  try {
+    return !isOpenAIOrChatGPTHost(new URL(provider.baseUrl).hostname);
+  } catch {
+    return true;
+  }
+}
+
+export function buildNonOpenAIToolCatalogNudgeFromNames(wireNames: readonly string[] | undefined): string | undefined {
+  const names = uniqueNames(wireNames ?? []);
+  if (names.length === 0) return undefined;
+
+  const advertised = new Set(names);
+  const unavailableNeighborNames = NEIGHBOR_AGENT_TOOL_NAMES.filter(name => !advertised.has(name));
+
+  return [
+    "Tool contract: use the current tool catalog as ground truth.",
+    `Valid tool names for this turn are exactly ${quoteNames(names)}.`,
+    "Call only listed names with their listed argument keys; do not invent, translate, or rename tools.",
+    unavailableNeighborNames.length > 0
+      ? `Do not use neighboring-agent tool names ${quoteNames(unavailableNeighborNames)} unless this turn's catalog lists those exact names.`
+      : undefined,
+    "If you need shell, file search, file read, edit, or discovery behavior, choose the listed tool that provides that capability.",
+    "Count a tool call only after its tool result returns; batch independent read-only calls when the runtime supports it.",
+  ].filter((line): line is string => typeof line === "string").join(" ");
+}
+
+export function buildNonOpenAIToolCatalogNudgeForTools(
+  tools: readonly Pick<OcxTool, "namespace" | "name">[] | undefined,
+  toolChoice?: OcxRequestOptions["toolChoice"],
+  toWireName: (tool: Pick<OcxTool, "namespace" | "name">) => string = tool => namespacedToolName(tool.namespace, tool.name),
+): string | undefined {
+  const visibleNames = tools
+    ?.filter(tool => toolChoiceAllows(tool, toolChoice))
+    .map(toWireName);
+  return buildNonOpenAIToolCatalogNudgeFromNames(visibleNames);
+}

package/src/adapters/upstream-http-error.ts

@@ -0,0 +1,48 @@
+import { readBoundedResponseBody } from "../lib/bounded-body";
+import { redactSecretString } from "../lib/redact";
+
+const ABSOLUTE_PATH_PATTERN = /(?:\/Users\/[^ "';,]+|\/home\/[^ "';,]+|\/root\/[^ "';,]*|[A-Za-z]:\\Users\\[^ "';,]+)/g;
+
+export function sanitizeUpstreamErrorText(value: string): string {
+  return redactSecretString(value).replace(ABSOLUTE_PATH_PATTERN, "[REDACTED_PATH]");
+}
+
+export function safeUpstreamErrorString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+export function parseUpstreamJsonPayload(payloadText: string): unknown | undefined {
+  const trimmed = payloadText.trim();
+  if (!trimmed || (!trimmed.startsWith("{") && !trimmed.startsWith("["))) return undefined;
+  try {
+    return JSON.parse(trimmed) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function readDisplaySafeErrorPayloadText(res: Response, signal?: AbortSignal): Promise<string> {
+  try {
+    const body = await readBoundedResponseBody(res, { signal });
+    return body.displaySafe ? body.text : "";
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return "";
+  }
+}
+
+export async function normalizeUpstreamHttpErrorResponse(
+  res: Response,
+  opts: { signal?: AbortSignal; formatMessage: (payloadText: string) => string | Promise<string> },
+): Promise<Response> {
+  if (res.ok) return res;
+  const payloadText = await readDisplaySafeErrorPayloadText(res, opts.signal);
+  const headers = new Headers(res.headers);
+  headers.delete("content-encoding");
+  headers.delete("content-length");
+  return new Response(await opts.formatMessage(payloadText), {
+    status: res.status,
+    statusText: res.statusText,
+    headers,
+  });
+}