@jeffusion/bungee-core 5.10.0 → 5.12.0

package/dist/plugins/chatgpt-oauth/index.js

@@ -14770,6 +14770,512 @@ var require_winston_daily_rotate_file = __commonJS(function(exports, module) {
   module.exports = DailyRotateFile;
 });
 
+// packages/core/src/plugin-services/host-rpc.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// packages/core/src/plugin-services/wire-contract.ts
+import { isProxy } from "util/types";
+var RPC_JSON_MAX_BYTES = 64 * 1024;
+var RPC_CONTRACT_MAX_BYTES = 256 * 1024;
+var JSON_MAX_DEPTH = 64;
+var SCHEMA_MAX_DEPTH = 64;
+var RPC_MAX_TIMEOUT_MS = 300000;
+var RPC_MAX_METHODS = 128;
+var RPC_SERVICE_ID = /^[a-z][a-z0-9.-]{0,127}$/;
+var RPC_METHOD_NAME = /^[A-Za-z_][A-Za-z0-9_.-]{0,127}$/;
+var RPC_CALL_PURPOSES = new Set(["bootstrap", "background", "management", "request", "attempt"]);
+var RPC_COMMAND_DEDUPLICATION = new Set(["local-transaction", "external-contract", "none"]);
+var RPC_COMMAND_POLICY_KEYS = new Set(["deduplication", "resultRetentionMs", "quotaBytes", "maxResultBytes"]);
+var CONTRACT_KEYS = ["id", "version", "methods"];
+var METHOD_KEYS = [
+  "kind",
+  "input",
+  "output",
+  "purposes",
+  "timeoutMs",
+  "maxInputBytes",
+  "maxOutputBytes",
+  "command"
+];
+
+class RpcProtocolError extends Error {
+  code;
+  name = "RpcProtocolError";
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+function failData(category) {
+  throw new RpcProtocolError("invalid_data", `invalid_data in ${category}`);
+}
+function failSize() {
+  throw new RpcProtocolError("size_limit", "size_limit: JSON value exceeds the byte limit");
+}
+function failContract(reason) {
+  throw new RpcProtocolError("invalid_contract", `invalid_contract: ${reason}`);
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  if (isProxy(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isNonNegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function hasLoneSurrogate(value) {
+  for (let index = 0;index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      if (index + 1 >= value.length)
+        return true;
+      const next = value.charCodeAt(index + 1);
+      if (next < 56320 || next > 57343)
+        return true;
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      return true;
+    }
+  }
+  return false;
+}
+function isArrayIndex(key, length) {
+  if (!/^(?:0|[1-9]\d*)$/.test(key))
+    return false;
+  const index = Number(key);
+  return Number.isSafeInteger(index) && index >= 0 && index < length;
+}
+function assertKnownKeys(input, allowed, category) {
+  for (const key of Object.keys(input)) {
+    if (!allowed.includes(key))
+      failContract(`unknown ${category} field`);
+  }
+}
+function spend(budget, bytes) {
+  budget.left -= bytes;
+  if (budget.left < 0)
+    failSize();
+}
+function snapshot(value, depth, ancestors, budget) {
+  if (value === null) {
+    spend(budget, 4);
+    return null;
+  }
+  if (typeof value === "boolean") {
+    spend(budget, value ? 4 : 5);
+    return value;
+  }
+  if (typeof value === "string") {
+    if (hasLoneSurrogate(value))
+      failData("string");
+    spend(budget, Buffer.byteLength(value, "utf8") + 2);
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      failData("number");
+    spend(budget, 1);
+    return value;
+  }
+  if (typeof value !== "object")
+    failData("json");
+  const object = value;
+  if (isProxy(object))
+    failData("json");
+  if (ancestors.has(object))
+    failData("json");
+  const nextDepth = depth + 1;
+  if (nextDepth > JSON_MAX_DEPTH)
+    failData("json");
+  if (Array.isArray(object)) {
+    if (Object.getPrototypeOf(object) !== Array.prototype)
+      failData("array");
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(object, "length");
+    if (!lengthDescriptor || !("value" in lengthDescriptor) || typeof lengthDescriptor.value !== "number") {
+      failData("array");
+    }
+    const length = lengthDescriptor.value;
+    if (!Number.isSafeInteger(length) || length < 0)
+      failData("array");
+    if (length > budget.left)
+      failSize();
+    spend(budget, 2);
+    if (length > 1)
+      spend(budget, length - 1);
+    ancestors.add(object);
+    const items = new Array(length);
+    let count = 0;
+    for (const key of Reflect.ownKeys(object)) {
+      if (key === "length")
+        continue;
+      if (typeof key !== "string" || !isArrayIndex(key, length))
+        failData("array");
+      const descriptor = Object.getOwnPropertyDescriptor(object, key);
+      if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+        failData("array");
+      items[Number(key)] = snapshot(descriptor.value, nextDepth, ancestors, budget);
+      count += 1;
+    }
+    if (count !== length)
+      failData("array");
+    ancestors.delete(object);
+    return items;
+  }
+  const prototype = Object.getPrototypeOf(object);
+  if (prototype !== Object.prototype && prototype !== null)
+    failData("object");
+  const keys = Reflect.ownKeys(object);
+  if (keys.length > budget.left)
+    failSize();
+  spend(budget, 2);
+  if (keys.length > 1)
+    spend(budget, keys.length - 1);
+  ancestors.add(object);
+  const result = {};
+  for (const key of keys) {
+    if (typeof key !== "string")
+      failData("object");
+    if (hasLoneSurrogate(key))
+      failData("object");
+    const descriptor = Object.getOwnPropertyDescriptor(object, key);
+    if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+      failData("object");
+    spend(budget, Buffer.byteLength(key, "utf8") + 3);
+    Object.defineProperty(result, key, {
+      value: snapshot(descriptor.value, nextDepth, ancestors, budget),
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  ancestors.delete(object);
+  return result;
+}
+function snapshotPureInput(input) {
+  try {
+    const pure = snapshot(input, 0, new Set, { left: RPC_CONTRACT_MAX_BYTES });
+    if (Buffer.byteLength(JSON.stringify(pure), "utf8") > RPC_CONTRACT_MAX_BYTES)
+      failContract("input must be bounded pure JSON data");
+    return pure;
+  } catch (error) {
+    if (error instanceof RpcProtocolError && (error.code === "invalid_data" || error.code === "size_limit")) {
+      failContract("input must be bounded pure JSON data");
+    }
+    throw error;
+  }
+}
+function checkOptionalNonNegative(value, field) {
+  if (value === undefined)
+    return;
+  if (!isNonNegativeSafeInteger(value))
+    failContract(`${field} must be a non-negative safe integer`);
+  return value;
+}
+function checkOptionalFinite(value, field) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isFinite(value))
+    failContract(`${field} must be a finite number`);
+  return value;
+}
+function checkSchema(input, depth, seen) {
+  if (depth > SCHEMA_MAX_DEPTH)
+    failContract("schema nesting exceeds the limit");
+  if (!isPlainObject(input))
+    failContract("schema must be a plain object");
+  if (seen.has(input))
+    failContract("schema must not contain cycles");
+  seen.add(input);
+  const type = input.type;
+  if (type === "string") {
+    assertKnownKeys(input, ["type", "minLength", "maxLength"], "schema");
+    const min = checkOptionalNonNegative(input.minLength, "minLength");
+    const max = checkOptionalNonNegative(input.maxLength, "maxLength");
+    if (min !== undefined && max !== undefined && min > max)
+      failContract("string minLength must not exceed maxLength");
+  } else if (type === "number") {
+    assertKnownKeys(input, ["type", "integer", "minimum", "maximum"], "schema");
+    if (input.integer !== undefined && typeof input.integer !== "boolean")
+      failContract("number integer flag must be boolean");
+    const min = checkOptionalFinite(input.minimum, "minimum");
+    const max = checkOptionalFinite(input.maximum, "maximum");
+    if (min !== undefined && max !== undefined && min > max)
+      failContract("number minimum must not exceed maximum");
+  } else if (type === "boolean") {
+    assertKnownKeys(input, ["type"], "schema");
+  } else if (type === "null") {
+    assertKnownKeys(input, ["type"], "schema");
+  } else if (type === "literal") {
+    assertKnownKeys(input, ["type", "value"], "schema");
+    if (!Object.prototype.hasOwnProperty.call(input, "value"))
+      failContract("literal schema requires a value");
+    try {
+      snapshot(input.value, 0, new Set, { left: Infinity });
+    } catch (error) {
+      if (error instanceof RpcProtocolError && error.code === "invalid_data") {
+        failContract("literal value must be pure JSON");
+      }
+      throw error;
+    }
+  } else if (type === "array") {
+    assertKnownKeys(input, ["type", "items", "maxItems"], "schema");
+    if (!Object.prototype.hasOwnProperty.call(input, "items"))
+      failContract("array schema requires items");
+    checkSchema(input.items, depth + 1, seen);
+    checkOptionalNonNegative(input.maxItems, "maxItems");
+  } else if (type === "object") {
+    assertKnownKeys(input, ["type", "properties", "optional"], "schema");
+    const properties = input.properties;
+    if (!isPlainObject(properties))
+      failContract("object schema requires a properties record");
+    for (const key of Object.keys(properties))
+      checkSchema(properties[key], depth + 1, seen);
+    const optional = input.optional;
+    if (optional !== undefined) {
+      if (!Array.isArray(optional))
+        failContract("object optional must be an array of field names");
+      const names = new Set;
+      for (const name of optional) {
+        if (typeof name !== "string")
+          failContract("object optional entries must be strings");
+        if (names.has(name))
+          failContract("object optional entries must be unique");
+        names.add(name);
+        if (!Object.prototype.hasOwnProperty.call(properties, name)) {
+          failContract("object optional names must exist in properties");
+        }
+      }
+    }
+  } else if (type === "record") {
+    assertKnownKeys(input, ["type", "values", "maxEntries"], "schema");
+    if (!Object.prototype.hasOwnProperty.call(input, "values"))
+      failContract("record schema requires values");
+    checkSchema(input.values, depth + 1, seen);
+    checkOptionalNonNegative(input.maxEntries, "maxEntries");
+  } else if (type === "union") {
+    assertKnownKeys(input, ["type", "variants"], "schema");
+    const variants = input.variants;
+    if (!Array.isArray(variants) || variants.length === 0) {
+      failContract("union schema requires a non-empty variants array");
+    }
+    for (const variant of variants)
+      checkSchema(variant, depth + 1, seen);
+  } else if (type === "json") {
+    assertKnownKeys(input, ["type", "maxBytes"], "schema");
+    if (input.maxBytes !== undefined && !isPositiveSafeInteger(input.maxBytes)) {
+      failContract("json schema maxBytes must be a positive safe integer");
+    }
+  } else {
+    failContract("unknown schema type");
+  }
+  seen.delete(input);
+}
+function checkByteLimit(value, field) {
+  if (value === undefined)
+    return;
+  if (!isPositiveSafeInteger(value) || value > RPC_JSON_MAX_BYTES) {
+    failContract(`${field} must be a positive integer no larger than the RPC envelope`);
+  }
+  return value;
+}
+function checkCommandPolicy(policy, maxOutputBytes) {
+  const keys = Object.keys(policy);
+  if (keys.length !== RPC_COMMAND_POLICY_KEYS.size || keys.some((key) => !RPC_COMMAND_POLICY_KEYS.has(key))) {
+    failContract("command policy fields are fixed");
+  }
+  const deduplication = policy.deduplication;
+  if (typeof deduplication !== "string" || !RPC_COMMAND_DEDUPLICATION.has(deduplication)) {
+    failContract("invalid command deduplication");
+  }
+  const retention = policy.resultRetentionMs;
+  if (retention !== null && !isPositiveSafeInteger(retention)) {
+    failContract("resultRetentionMs must be a positive integer or null");
+  }
+  const maxResultBytes = policy.maxResultBytes;
+  if (!isPositiveSafeInteger(maxResultBytes))
+    failContract("maxResultBytes must be a positive safe integer");
+  if (maxResultBytes > maxOutputBytes)
+    failContract("maxResultBytes must not exceed maxOutputBytes");
+  const quotaBytes = policy.quotaBytes;
+  if (!isPositiveSafeInteger(quotaBytes))
+    failContract("quotaBytes must be a positive safe integer");
+  if (quotaBytes < maxResultBytes)
+    failContract("quotaBytes must be able to hold maxResultBytes");
+}
+function checkMethod(definition) {
+  assertKnownKeys(definition, METHOD_KEYS, "method");
+  const kind = definition.kind;
+  if (kind !== "query" && kind !== "command")
+    failContract("method kind must be query or command");
+  checkSchema(definition.input, 0, new Set);
+  checkSchema(definition.output, 0, new Set);
+  const purposes = definition.purposes;
+  if (!Array.isArray(purposes) || purposes.length === 0)
+    failContract("purposes must be a non-empty array");
+  const seenPurposes = new Set;
+  for (const purpose of purposes) {
+    if (typeof purpose !== "string" || !RPC_CALL_PURPOSES.has(purpose))
+      failContract("invalid purpose");
+    if (seenPurposes.has(purpose))
+      failContract("purposes must be unique");
+    seenPurposes.add(purpose);
+  }
+  if (definition.timeoutMs !== undefined) {
+    if (!isPositiveSafeInteger(definition.timeoutMs) || definition.timeoutMs > RPC_MAX_TIMEOUT_MS) {
+      failContract("timeoutMs must be a positive integer no larger than the timeout bound");
+    }
+  }
+  checkByteLimit(definition.maxInputBytes, "maxInputBytes");
+  const maxOutputBytes = checkByteLimit(definition.maxOutputBytes, "maxOutputBytes");
+  const command = definition.command;
+  if (kind === "command") {
+    if (!isPlainObject(command))
+      failContract("command methods require an explicit command policy");
+    checkCommandPolicy(command, maxOutputBytes ?? RPC_JSON_MAX_BYTES);
+  } else if (command !== undefined) {
+    failContract("query methods must not declare a command policy");
+  }
+}
+function checkContract(contract) {
+  if (!isPlainObject(contract))
+    failContract("contract must be a plain object");
+  assertKnownKeys(contract, CONTRACT_KEYS, "contract");
+  if (typeof contract.id !== "string" || !RPC_SERVICE_ID.test(contract.id))
+    failContract("invalid service id");
+  if (!isPositiveSafeInteger(contract.version))
+    failContract("service version must be a positive safe integer");
+  const methods = contract.methods;
+  if (!isPlainObject(methods))
+    failContract("methods must be a plain object");
+  const names = Object.keys(methods);
+  if (names.length === 0)
+    failContract("service must declare at least one method");
+  if (names.length > RPC_MAX_METHODS)
+    failContract("service declares too many methods");
+  for (const name of names) {
+    if (!RPC_METHOD_NAME.test(name))
+      failContract("invalid method name");
+    const definition = methods[name];
+    if (!isPlainObject(definition))
+      failContract("method definition must be a plain object");
+    checkMethod(definition);
+  }
+}
+function deepFreeze(value) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      deepFreeze(item);
+    return Object.freeze(value);
+  }
+  if (isPlainObject(value)) {
+    for (const key of Object.keys(value))
+      deepFreeze(value[key]);
+    return Object.freeze(value);
+  }
+  return value;
+}
+function defineRpcService(contract) {
+  const pure = snapshotPureInput(contract);
+  checkContract(pure);
+  return deepFreeze(pure);
+}
+
+// packages/core/src/plugin-services/rpc-runtime.ts
+var PROCESSES = new Set(["control", "worker", "ingress"]);
+var SCOPES = new Set(["global", "binding"]);
+var PURPOSES = new Set(["bootstrap", "background", "management", "request", "attempt"]);
+var ENDPOINTS = new WeakMap;
+var REVOKED = new WeakMap;
+
+// packages/core/src/plugin-services/host-rpc.ts
+var SERVICE_ERROR_MESSAGES = {
+  unauthorized: "RPC call is not authorized",
+  not_ready: "RPC endpoint is not ready",
+  retired: "RPC endpoint is retiring",
+  revoked: "RPC endpoint generation was revoked",
+  unsupported_method: "RPC method is not published",
+  wrong_purpose: "RPC method is not published for this purpose",
+  invalid_input: "RPC input is not valid",
+  invalid_output: "RPC output is not valid",
+  invalid_operation_id: "RPC command operation id is invalid",
+  overloaded: "RPC runtime is at capacity",
+  cancelled: "RPC call was cancelled",
+  timeout: "RPC call deadline exceeded",
+  unknown: "RPC command outcome is unknown",
+  capability_unavailable: "RPC command execution is unavailable",
+  closed: "RPC runtime is closed",
+  failed: "RPC call failed",
+  conflict: "RPC command identity conflicts with an existing record",
+  expired: "RPC command result has expired",
+  pending: "RPC command is still pending",
+  rejected: "RPC command was rejected",
+  missing: "RPC command has no stored result",
+  storage_failure: "RPC command storage failed",
+  deadlock: "RPC call chain would deadlock",
+  call_depth_exceeded: "RPC call depth exceeded",
+  undeclared: "RPC service is not declared by the manifest",
+  unavailable: "RPC service is unavailable",
+  ambiguous_placement: "RPC service placement is ambiguous",
+  invalid_registration: "RPC registration is invalid"
+};
+var SERVICE_ERROR_CODES = new Set(Object.keys(SERVICE_ERROR_MESSAGES));
+var EMPTY_OPTIONS = Object.freeze({});
+var FRAME_STORE = new AsyncLocalStorage;
+var CALLEE_INFO = new WeakMap;
+// packages/core/src/plugin-services/peer-channel-protocol.ts
+var CHANNEL_REQUEST_MAX_BYTES = 4 * 1024;
+var CHANNEL_RESULT_MAX_BYTES = 60 * 1024;
+var CHANNEL_MAX_CHUNK_BYTES = 60 * 1024;
+var PLUGIN_CHANNEL_LANES = Object.freeze(["event", "snapshot", "stream"]);
+var ERROR_CODES = new Set([
+  "unavailable",
+  "ambiguous",
+  "unauthorized",
+  "invalid",
+  "overloaded",
+  "expired",
+  "conflict",
+  "gap",
+  "truncated",
+  "rejected",
+  "cancelled",
+  "closed",
+  "unknown",
+  "failed"
+]);
+var RPC_CALL_PURPOSES2 = new Set(["bootstrap", "background", "management", "request", "attempt"]);
+
+// packages/core/src/plugin-services/peer-channel-hub.ts
+var CHANNEL_MAX_TRANSFER_BUFFER_BYTES = 4 * CHANNEL_MAX_CHUNK_BYTES;
+var CHANNEL_MAX_TOTAL_BUFFER_BYTES = 16 * CHANNEL_MAX_CHUNK_BYTES;
+var CHANNEL_STREAM_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+var CHANNEL_STREAM_MAX_CREDIT_BYTES = 8 * CHANNEL_MAX_CHUNK_BYTES;
+var CHANNEL_STREAM_DEFAULT_CREDIT_BYTES = 4 * CHANNEL_MAX_CHUNK_BYTES;
+var CHANNEL_SNAPSHOT_MAX_BYTES = 64 * 1024 * 1024;
+var CHANNEL_EVENT_MAX_PAYLOAD_BYTES = 60 * 1024;
+var EMPTY = new Uint8Array(0);
+var HANDLE_REGISTRATIONS = new WeakMap;
+
+// packages/core/src/plugin-services/snapshot-store.ts
+var DEFAULT_CHUNK_BYTES = 60 * 1024;
+var SNAPSHOT_FAMILY_REFS = new Map;
+
+// packages/core/src/plugin-services.ts
+var CHANNEL_KINDS = new Set(["events", "snapshot", "stream"]);
+
+// plugins/chatgpt-oauth/server/rpc.ts
+var command = { deduplication: "none", resultRetentionMs: null, quotaBytes: 65536, maxResultBytes: 65536 };
+var businessRpc = defineRpcService({ id: "chatgpt-oauth.credentials.v1", version: 1, methods: {
+  getCredential: { kind: "command", input: { type: "object", properties: {} }, output: { type: "object", properties: { version: { type: "number", integer: true, minimum: 1 }, expiresAt: { type: "number" }, headers: { type: "record", values: { type: "string" }, maxEntries: 16 } } }, purposes: ["attempt"], command, timeoutMs: 15000 },
+  rejectAccess: { kind: "command", input: { type: "object", properties: { version: { type: "number", integer: true, minimum: 1 } } }, output: { type: "object", properties: { rejected: { type: "boolean" } } }, purposes: ["attempt"], command, timeoutMs: 15000 }
+} });
+
 // packages/core/src/logger.ts
 var import_winston = __toESM(require_winston());
 var import_winston_daily_rotate_file = __toESM(require_winston_daily_rotate_file());
@@ -15282,6 +15788,14 @@ async function* parseCodexSSE(source, options = {}) {
     yield* consumeLine(remainingLine);
   yield* dispatch();
 }
+function chatToolCall(state, value, includeIdentity, preserveCustomTools) {
+  const custom = preserveCustomTools && state.kind === "custom_tool_call";
+  return {
+    index: state.index,
+    ...includeIdentity ? { id: state.id, type: custom ? "custom" : "function" } : {},
+    [custom ? "custom" : "function"]: { ...includeIdentity ? { name: state.name } : {}, [custom ? "input" : "arguments"]: value }
+  };
+}
 function streamIncludesUsage(request) {
   return request?.stream_options?.include_usage === true;
 }
@@ -15366,6 +15880,7 @@ class CodexResponseProcessor {
   output = [];
   includeUsage;
   target;
+  preserveCustomTools;
   text = "";
   reasoning = "";
   messageText = new Map;
@@ -15385,6 +15900,7 @@ class CodexResponseProcessor {
   constructor(options = {}) {
     this.includeUsage = options.includeUsage ?? (options.request ? streamIncludesUsage(options.request) : false);
     this.target = options.target ?? "chat";
+    this.preserveCustomTools = options.preserveCustomTools ?? false;
     this.redactDiagnostic = options.redactDiagnostic;
   }
   validateOutputItem(item) {
@@ -15555,7 +16071,7 @@ class CodexResponseProcessor {
         this.tools.set(`output:${String(data.output_index)}`, state);
       const chunk = base();
       chunk.choices[0].delta.role = "assistant";
-      chunk.choices[0].delta.tool_calls = [{ index: state.index, id: state.id, type: "function", function: { name: state.name, arguments: "" } }];
+      chunk.choices[0].delta.tool_calls = [chatToolCall(state, "", true, this.preserveCustomTools)];
       output.push(chunk);
     } else if (type === "response.function_call_arguments.delta" || type === "response.custom_tool_call_input.delta") {
       const state = this.findTool(data);
@@ -15564,7 +16080,7 @@ class CodexResponseProcessor {
         state.arguments += delta;
         state.emittedArguments = true;
         const chunk = base();
-        chunk.choices[0].delta.tool_calls = [{ index: state.index, function: { arguments: delta } }];
+        chunk.choices[0].delta.tool_calls = [chatToolCall(state, delta, false, this.preserveCustomTools)];
         output.push(chunk);
       }
     } else if (type === "response.function_call_arguments.done" || type === "response.custom_tool_call_input.done") {
@@ -15575,7 +16091,7 @@ class CodexResponseProcessor {
       if (state && !state.emittedArguments && state.arguments) {
         state.emittedArguments = true;
         const chunk = base();
-        chunk.choices[0].delta.tool_calls = [{ index: state.index, function: { arguments: state.arguments } }];
+        chunk.choices[0].delta.tool_calls = [chatToolCall(state, state.arguments, false, this.preserveCustomTools)];
         output.push(chunk);
       }
     } else if (type === "response.output_item.done") {
@@ -15589,7 +16105,7 @@ class CodexResponseProcessor {
           if (!state.emittedArguments && state.arguments) {
             state.emittedArguments = true;
             const chunk = base();
-            chunk.choices[0].delta.tool_calls = [{ index: state.index, function: { arguments: state.arguments } }];
+            chunk.choices[0].delta.tool_calls = [chatToolCall(state, state.arguments, false, this.preserveCustomTools)];
             output.push(chunk);
           }
         } else {
@@ -15599,7 +16115,7 @@ class CodexResponseProcessor {
           if (data.output_index !== undefined)
             this.tools.set(`output:${String(data.output_index)}`, state2);
           const chunk = base();
-          chunk.choices[0].delta.tool_calls = [{ index: state2.index, id: state2.id, type: "function", function: { name: state2.name, arguments: state2.arguments } }];
+          chunk.choices[0].delta.tool_calls = [chatToolCall(state2, state2.arguments, true, this.preserveCustomTools)];
           output.push(chunk);
         }
         this.upsertOutput(item, data.output_index === undefined ? undefined : Number(data.output_index), this.target === "responses", data.content_index === undefined ? undefined : Number(data.content_index), typeof data.item_id === "string" ? data.item_id : undefined);
@@ -15724,7 +16240,7 @@ async function consumeCodexResponse(source, options = {}) {
     processor.process(event);
   return processor.finish();
 }
-function responsesToChatCompletion(response) {
+function responsesToChatCompletion(response, preserveCustomTools = false) {
   let content = "";
   let reasoning = "";
   const tool_calls = [];
@@ -15737,7 +16253,9 @@ function responsesToChatCompletion(response) {
       content += textFromItem(item);
     if (item.type === "reasoning")
       reasoning += (item.summary ?? []).filter((part) => part.type === "summary_text").map((part) => String(part.text ?? "")).join("") + (item.content ?? []).filter((part) => part.type === "reasoning_text").map((part) => String(part.text ?? "")).join("");
-    if (item.type === "function_call" || item.type === "custom_tool_call")
+    if (item.type === "custom_tool_call" && preserveCustomTools)
+      tool_calls.push({ id: item.call_id, type: "custom", custom: { name: item.name, input: String(item.input ?? "") } });
+    else if (item.type === "function_call" || item.type === "custom_tool_call")
       tool_calls.push({ id: item.call_id, type: "function", function: { name: item.name, arguments: String(item.arguments ?? item.input ?? "") } });
     if (item.type === "image_generation_call" && item.result)
       images.push({ type: "image_url", image_url: { url: `data:${imageMime(item.output_format)};base64,${item.result}` } });
@@ -15840,13 +16358,140 @@ var MAX_DISCARD_BYTES = 64 * 1024;
 var MAX_MODELS_BODY_BYTES = 256 * 1024;
 var MAX_PROFILE_HEADER_VALUE_BYTES = 8192;
 var CHATGPT_ORIGIN = "https://chatgpt.com";
+var SIWC_ORIGIN = "https://api.openai.com";
 var CODEX_ROUTING_HINT_HEADER = "X-Codex-Routing-Hint";
+var SIWC_FORBIDDEN_FIELDS = [
+  "background",
+  "conversation",
+  "max_output_tokens",
+  "max_completion_tokens",
+  "max_tool_calls",
+  "metadata",
+  "moderation",
+  "multi_agent",
+  "prompt",
+  "prompt_cache_retention",
+  "safety_identifier",
+  "temperature",
+  "top_logprobs",
+  "top_p",
+  "truncation",
+  "user",
+  "previous_response_id",
+  "client_metadata",
+  "context_management",
+  "prompt_cache_options"
+];
 function record(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new CodexProtocolError("invalid_response", "Request must be a JSON object");
   }
   return value;
 }
+function siwcTool(tool) {
+  const value = record(tool);
+  if (value.type !== "function" && value.type !== "custom") {
+    throw new CodexProtocolError("invalid_response", "SIWC supports only function and custom tools");
+  }
+  const nested = value.type === "function" ? value.function : value.custom;
+  const definition = nested === undefined ? value : record(nested);
+  if (typeof definition.name !== "string" || !/^[A-Za-z0-9_-]{1,64}$/.test(definition.name)) {
+    throw new CodexProtocolError("invalid_response", "SIWC tool names must be 1-64 ASCII letters, digits, underscores or hyphens");
+  }
+  const normalized = { ...definition, type: value.type };
+  if (value.type === "custom" && normalized.format?.type === "grammar" && normalized.format.grammar !== undefined) {
+    const grammar = record(normalized.format.grammar);
+    if (!["lark", "regex"].includes(grammar.syntax) || typeof grammar.definition !== "string") {
+      throw new CodexProtocolError("invalid_response", "SIWC custom tool grammar is invalid");
+    }
+    normalized.format = { type: "grammar", syntax: grammar.syntax, definition: grammar.definition };
+  }
+  return normalized;
+}
+function normalizeSiwcRequest(input, target) {
+  if (input.previous_response_id !== undefined) {
+    throw new CodexProtocolError("invalid_response", "SIWC requires the full conversation in input; previous_response_id is unsupported");
+  }
+  if (input.tools !== undefined && !Array.isArray(input.tools)) {
+    throw new CodexProtocolError("invalid_response", "SIWC tools must be an array");
+  }
+  input.tools?.forEach(siwcTool);
+  if (target === "chat" && !Array.isArray(input.messages)) {
+    throw new CodexProtocolError("invalid_response", "Chat messages must be an array");
+  }
+  const out = target === "chat" ? convertChatCompletionsRequestToCodex(input) : JSON.parse(JSON.stringify(input));
+  out.store = false;
+  out.stream = true;
+  if (out.instructions === undefined || out.instructions === null)
+    out.instructions = "";
+  if (typeof out.instructions !== "string")
+    throw new CodexProtocolError("invalid_response", "SIWC instructions must be text");
+  if (typeof out.input === "string")
+    out.input = [{ type: "message", role: "user", content: [{ type: "input_text", text: out.input }] }];
+  if (out.input === undefined)
+    out.input = [];
+  if (!Array.isArray(out.input))
+    throw new CodexProtocolError("invalid_response", "SIWC input must contain the full conversation as an array");
+  const inputTypes = new Set(["message", "function_call", "function_call_output", "custom_tool_call", "custom_tool_call_output", "reasoning", "compaction"]);
+  for (const item of out.input) {
+    const value = record(item);
+    if (value.type === undefined && typeof value.role === "string")
+      value.type = "message";
+    if (!inputTypes.has(value.type))
+      throw new CodexProtocolError("invalid_response", "SIWC input contains an unsupported item");
+    if (value.type === "message") {
+      if (!["system", "developer", "user", "assistant"].includes(value.role))
+        throw new CodexProtocolError("invalid_response", "SIWC input contains an unsupported role");
+      if (value.role === "system")
+        value.role = "developer";
+    }
+  }
+  if (Array.isArray(out.tools))
+    out.tools = out.tools.map(siwcTool);
+  if (out.tool_choice !== undefined) {
+    if (typeof out.tool_choice === "string") {
+      if (!["auto", "none", "required"].includes(out.tool_choice))
+        throw new CodexProtocolError("invalid_response", "SIWC tool choice is unsupported");
+    } else
+      out.tool_choice = siwcTool(out.tool_choice);
+  }
+  for (const field of SIWC_FORBIDDEN_FIELDS)
+    delete out[field];
+  return out;
+}
+function setSiwcHeaders(context, target) {
+  for (const name of Object.keys(context.headers)) {
+    if (/^(chatgpt-account-id|session-id|thread-id|version|x-codex-.*|x-openai-internal-codex-.*)$/i.test(name))
+      delete context.headers[name];
+  }
+  setHeader(context.headers, "User-Agent", "Bungee/5.11.0");
+  setHeader(context.headers, "Originator", "Bungee");
+  setHeader(context.headers, "Accept", target === "models" ? "application/json" : "text/event-stream");
+  if (target !== "models")
+    setHeader(context.headers, "Content-Type", "application/json");
+}
+function parseSiwcModelsBody(body) {
+  let payload;
+  try {
+    payload = JSON.parse(body);
+  } catch {
+    throw new CodexModelsError("invalid_json");
+  }
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload))
+    throw new CodexModelsError("invalid_structure");
+  const models = payload.models;
+  if (!Array.isArray(models) || models.length > 512)
+    throw new CodexModelsError("invalid_structure");
+  const text = (value) => typeof value === "string" && value.length > 0 && value.length <= 512 && value === value.trim() && !/[\r\n\0]/.test(value);
+  const listed = [];
+  for (const model of models) {
+    if (!model || typeof model !== "object" || Array.isArray(model) || !text(model.slug) || typeof model.visibility !== "string" || model.display_name !== undefined && !text(model.display_name))
+      throw new CodexModelsError("invalid_structure");
+    if (model.visibility === "list")
+      listed.push({ id: model.slug });
+  }
+  return listed;
+}
 function validHeaderValue(value) {
   return typeof value === "string" && new TextEncoder().encode(value).byteLength <= MAX_PROFILE_HEADER_VALUE_BYTES && value.trim().length > 0 && !/[\r\n\0]/.test(value);
 }
@@ -15895,7 +16540,7 @@ function responseHeaders(response, contentType) {
   headers.set("content-type", contentType);
   return headers;
 }
-function errorBody(error, fallbackCode = "upstream_error") {
+function errorBody2(error, fallbackCode = "upstream_error") {
   return { message: error?.message ?? "Upstream response could not be adapted", type: error?.type ?? "upstream_error", code: error?.code ?? fallbackCode };
 }
 function completionFromError(error, redact) {
@@ -16071,7 +16716,7 @@ function serialize(event) {
 
 `;
 }
-function protocolStreamBody(source, target, includeUsage, signal, redact) {
+function protocolStreamBody(source, target, includeUsage, signal, redact, preserveCustomTools = false) {
   const protocolController = new AbortController;
   const onAbort = () => protocolController.abort(signal.reason ?? "cancelled");
   if (signal.aborted)
@@ -16089,7 +16734,7 @@ function protocolStreamBody(source, target, includeUsage, signal, redact) {
   const completion = new Promise((resolve) => {
     resolveCompletion = resolve;
   });
-  const processor = new CodexResponseProcessor({ target, includeUsage, redactDiagnostic: redact });
+  const processor = new CodexResponseProcessor({ target, includeUsage, redactDiagnostic: redact, preserveCustomTools });
   let terminalOutcome;
   const events = parseCodexSSE(source, { signal: protocolController.signal });
   const iterator = async function* () {
@@ -16119,7 +16764,7 @@ function protocolStreamBody(source, target, includeUsage, signal, redact) {
       const outcome = completionFromError(error, redact);
       settle(outcome.status === "cancelled" ? terminalOutcome ?? outcome : outcome);
       if (outcome.status === "failed" && outcome.error) {
-        const safe = errorBody(outcome.error, outcome.code);
+        const safe = errorBody2(outcome.error, outcome.code);
         yield target === "responses" ? `event: error
 data: ${JSON.stringify({ type: "error", code: safe.code, message: safe.message, param: null, error: safe })}
 
@@ -16161,6 +16806,26 @@ class ChatgptOauthAdapter {
   constructor() {}
   beforeRequest(context) {
     const target = context.url.pathname === MODELS_PATH ? "models" : context.url.pathname === CHAT_COMPLETIONS_PATH ? "chat" : context.url.pathname === RESPONSES_PATH ? "responses" : undefined;
+    if (context.url.origin === SIWC_ORIGIN) {
+      if (target === undefined)
+        return context;
+      const input = target === "models" ? undefined : record(context.body);
+      const stream = input?.stream === true;
+      const includeUsage = input ? streamIncludesUsage(input) : false;
+      context.body = input ? normalizeSiwcRequest(input, target) : undefined;
+      if (target !== "models")
+        context.url.pathname = RESPONSES_PATH;
+      setSiwcHeaders(context, target);
+      this.requests.set(context.requestId, Object.freeze({
+        target,
+        stream,
+        includeUsage,
+        siwc: true,
+        allowMissingContentType: target !== "models",
+        adaptedResponses: new WeakSet
+      }));
+      return context;
+    }
     if (context.url.pathname === CODEX_RESPONSES_PATH) {
       setCodexRoutingHint(context.headers, context.body);
       enforceCodexResponsesLite(context);
@@ -16216,6 +16881,14 @@ class ChatgptOauthAdapter {
     return context;
   }
   reconcileOutboundRequest(context) {
+    if (context.url.origin === SIWC_ORIGIN) {
+      if (context.url.pathname === RESPONSES_PATH) {
+        context.body = normalizeSiwcRequest(record(context.body), "responses");
+        setSiwcHeaders(context, "responses");
+      } else if (context.url.pathname === MODELS_PATH)
+        setSiwcHeaders(context, "models");
+      return context;
+    }
     if (context.url.pathname === CODEX_RESPONSES_PATH) {
       setCodexRoutingHint(context.headers, context.body);
       enforceCodexResponsesLite(context);
@@ -16239,7 +16912,7 @@ class ChatgptOauthAdapter {
       return response;
     };
     const errorResponse = (status, completion, error) => {
-      const response = mark(new Response(JSON.stringify({ error: errorBody(error) }), {
+      const response = mark(new Response(JSON.stringify({ error: errorBody2(error) }), {
         status,
         statusText: result.response.statusText,
         headers: responseHeaders(result.response, "application/json; charset=utf-8")
@@ -16260,7 +16933,8 @@ class ChatgptOauthAdapter {
         return errorResponse(502, joinCompletion(result.completion, Promise.resolve({ status: "failed", code: "invalid_response" }), context.signal));
       }
       try {
-        const models = parseCodexModelsBody(await readBoundedBody(result.response, context.signal), MAX_MODELS_BODY_BYTES);
+        const text = await readBoundedBody(result.response, context.signal);
+        const models = state.siwc ? parseSiwcModelsBody(text) : parseCodexModelsBody(text, MAX_MODELS_BODY_BYTES);
         const body = {
           object: "list",
           data: models.map(({ id }) => ({ id, object: "model", owned_by: "openai" }))
@@ -16286,7 +16960,7 @@ class ChatgptOauthAdapter {
       return errorResponse(502, joinCompletion(result.completion, bodyCompletion, context.signal));
     }
     if (state.stream) {
-      const converted = protocolStreamBody(result.response.body, state.target, state.includeUsage, context.signal, context.redactDiagnostic);
+      const converted = protocolStreamBody(result.response.body, state.target, state.includeUsage, context.signal, context.redactDiagnostic, state.siwc);
       const streamCompletion = joinCompletion(result.completion, converted.completion, context.signal);
       streamCompletion.then(cleanup, cleanup);
       return {
@@ -16301,7 +16975,7 @@ class ChatgptOauthAdapter {
         target: state.target,
         redactDiagnostic: context.redactDiagnostic
       });
-      const body = state.target === "chat" ? responsesToChatCompletion(stateResult.response) : stateResult.response;
+      const body = state.target === "chat" ? responsesToChatCompletion(stateResult.response, state.siwc) : stateResult.response;
       const protocolCompletion = Promise.resolve(stateResult.terminal === "completed" ? { status: "completed" } : { status: "incomplete", code: "incomplete" });
       const nonStreamCompletion = joinCompletion(result.completion, protocolCompletion, context.signal);
       nonStreamCompletion.then(cleanup, cleanup);
@@ -16319,6 +16993,7 @@ function validAccountRef(value) {
   return typeof value === "string" && value.length >= 1 && value.length <= 128 && value.trim() === value;
 }
 var ChatgptOauthPlugin = definePlugin(class {
+  static controlRpcContract = businessRpc;
   static name = "chatgpt-oauth";
   static version = "1.0.0";
   adapter;
@@ -16340,4 +17015,4 @@ export {
   server_default as default
 };
 
-//# debugId=D19FB0DB9863C8D864756E2164756E21
+//# debugId=9E89B5DD5BF3FADA64756E2164756E21