@jigging/jig 0.1.0-alpha.5 → 0.1.0-alpha.7

package/libexec/agent/codex-agent-launcher.js

@@ -0,0 +1,54 @@
+// @bun
+// src/internal/codex-agent-launcher.ts
+import { closeSync, mkdirSync, openSync, readSync, writeSync } from "fs";
+var STARTUP_INPUT_BYTES = 64 * 1024;
+var CODEX_HOME = "/tmp/codex-home";
+var CREDENTIAL_PATH = `${CODEX_HOME}/auth.json`;
+var ADAPTER_SPECIFIER = "./codex-acp.js";
+if (import.meta.main)
+  await main();
+async function main() {
+  mkdirSync(CODEX_HOME, { mode: 448 });
+  const startup = process.env.JIG_CODEX_STARTUP_INPUT;
+  if (startup !== undefined && startup !== "subscription") {
+    throw new Error("Codex startup input mode is invalid");
+  }
+  if (startup === "subscription")
+    materializeCredential();
+  delete process.env.JIG_CODEX_STARTUP_INPUT;
+  await import(ADAPTER_SPECIFIER);
+}
+function materializeCredential() {
+  const header = readExactly(4);
+  const size = new DataView(header.buffer, header.byteOffset, header.byteLength).getUint32(0, false);
+  if (size === 0 || size > STARTUP_INPUT_BYTES - 4) {
+    throw new Error("Codex startup input is invalid");
+  }
+  const credential = readExactly(size);
+  let descriptor;
+  try {
+    descriptor = openSync(CREDENTIAL_PATH, "wx", 384);
+    writeExactly(descriptor, credential);
+  } finally {
+    credential.fill(0);
+    if (descriptor !== undefined)
+      closeSync(descriptor);
+  }
+}
+function readExactly(size) {
+  const result = new Uint8Array(size);
+  let offset = 0;
+  while (offset < result.byteLength) {
+    const count = readSync(0, result, offset, result.byteLength - offset, null);
+    if (count === 0)
+      throw new Error("Codex startup input ended early");
+    offset += count;
+  }
+  return result;
+}
+function writeExactly(descriptor, value) {
+  let offset = 0;
+  while (offset < value.byteLength) {
+    offset += writeSync(descriptor, value, offset, value.byteLength - offset, null);
+  }
+}

package/libexec/agent/codex-requirements.toml

@@ -0,0 +1,5 @@
+allowed_approval_policies = ["on-request"]
+allowed_sandbox_modes = ["read-only", "workspace-write"]
+
+[permissions.filesystem]
+deny_read = ["/tmp/codex-home/auth.json"]

package/libexec/agent/{openrouter-responses-worker.js → openai-responses-worker.js}

@@ -13915,69 +13915,67 @@ function compareUtf16(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
-// src/internal/openrouter-responses-protocol.ts
-var PRIVATE_OPENROUTER_RESPONSES_PROTOCOL = "jig-private-openrouter-responses/1";
-var PRIVATE_OPENROUTER_RESPONSES_BASE_URL = "https://openrouter.ai/api/v1";
-var PRIVATE_OPENROUTER_RESPONSES_MODEL = "google/gemini-3.5-flash-lite";
-var PRIVATE_OPENROUTER_RESPONSES_REQUEST_BYTES = JSON_1_LIMITS.bytes;
-var PRIVATE_OPENROUTER_RESPONSES_RESPONSE_BYTES = JSON_1_LIMITS.bytes;
+// src/internal/openai-responses-protocol.ts
+var PRIVATE_OPENAI_RESPONSES_PROTOCOL = "jig-private-openai-responses/1";
+var PRIVATE_OPENAI_RESPONSES_REQUEST_BYTES = JSON_1_LIMITS.bytes;
+var PRIVATE_OPENAI_RESPONSES_RESPONSE_BYTES = JSON_1_LIMITS.bytes;
 var MAX_INSTRUCTION_CHARACTERS = 1048576;
 var MAX_RESPONSE_SCHEMA_BYTES = 256 * 1024;
 var MAX_FAILURE_MESSAGE_BYTES = 4096;
-var PRIVATE_OPENROUTER_RESPONSES_ERROR_CODES = Object.freeze([
+var PRIVATE_OPENAI_RESPONSES_ERROR_CODES = Object.freeze([
   "AGENT_PROVIDER_CONFIGURATION",
   "AGENT_PROVIDER_OUTPUT_LIMIT",
   "AGENT_PROVIDER_PROTOCOL",
   "AGENT_PROVIDER_RESPONSE_INVALID",
   "AGENT_PROVIDER_UNAVAILABLE"
 ]);
-var ERROR_CODES = new Set(PRIVATE_OPENROUTER_RESPONSES_ERROR_CODES);
+var ERROR_CODES = new Set(PRIVATE_OPENAI_RESPONSES_ERROR_CODES);
 
-class PrivateOpenRouterResponsesError extends Error {
+class PrivateOpenAIResponsesError extends Error {
   code;
   constructor(code, message) {
     super(message);
     this.code = code;
-    this.name = "PrivateOpenRouterResponsesError";
+    this.name = "PrivateOpenAIResponsesError";
   }
 }
-function decodePrivateOpenRouterResponsesRequest(bytes) {
-  if (bytes.byteLength === 0 || bytes.byteLength > PRIVATE_OPENROUTER_RESPONSES_REQUEST_BYTES) {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_PROTOCOL", "OpenRouter Responses worker request exceeds its byte bound");
+function decodePrivateOpenAIResponsesRequest(bytes) {
+  if (bytes.byteLength === 0 || bytes.byteLength > PRIVATE_OPENAI_RESPONSES_REQUEST_BYTES) {
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_PROTOCOL", "OpenAI Responses worker request exceeds its byte bound");
   }
   let value;
   try {
     value = decodeJson1(bytes);
   } catch {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_PROTOCOL", "OpenRouter Responses worker request is not valid JSON/1");
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_PROTOCOL", "OpenAI Responses worker request is not valid JSON/1");
   }
-  return requirePrivateOpenRouterResponsesRequest(value);
+  return requirePrivateOpenAIResponsesRequest(value);
 }
-function encodePrivateOpenRouterResponsesSuccess(value) {
-  const result = requirePrivateOpenRouterResponsesResult(value);
+function encodePrivateOpenAIResponsesSuccess(value) {
+  const result = requirePrivateOpenAIResponsesResult(value);
   return encodeBounded({
-    protocol: PRIVATE_OPENROUTER_RESPONSES_PROTOCOL,
+    protocol: PRIVATE_OPENAI_RESPONSES_PROTOCOL,
     status: "ok",
     value: result
-  }, PRIVATE_OPENROUTER_RESPONSES_RESPONSE_BYTES, "AGENT_PROVIDER_OUTPUT_LIMIT", "OpenRouter Responses worker result exceeds its byte bound");
+  }, PRIVATE_OPENAI_RESPONSES_RESPONSE_BYTES, "AGENT_PROVIDER_OUTPUT_LIMIT", "OpenAI Responses worker result exceeds its byte bound");
 }
-function encodePrivateOpenRouterResponsesFailure(code, message) {
+function encodePrivateOpenAIResponsesFailure(code, message) {
   if (!ERROR_CODES.has(code)) {
-    throw new TypeError("unknown OpenRouter Responses worker error code");
+    throw new TypeError("unknown OpenAI Responses worker error code");
   }
   const bounded = boundUtf8(message, MAX_FAILURE_MESSAGE_BYTES);
   return encodeBounded({
-    protocol: PRIVATE_OPENROUTER_RESPONSES_PROTOCOL,
+    protocol: PRIVATE_OPENAI_RESPONSES_PROTOCOL,
     status: "error",
     code,
     message: bounded
-  }, PRIVATE_OPENROUTER_RESPONSES_RESPONSE_BYTES, "AGENT_PROVIDER_OUTPUT_LIMIT", "OpenRouter Responses worker failure exceeds its byte bound");
+  }, PRIVATE_OPENAI_RESPONSES_RESPONSE_BYTES, "AGENT_PROVIDER_OUTPUT_LIMIT", "OpenAI Responses worker failure exceeds its byte bound");
 }
-function requirePrivateOpenRouterResponsesRequest(value) {
+function requirePrivateOpenAIResponsesRequest(value) {
   const record = ordinaryRecord(value);
   const hasSchema = record !== undefined && Object.hasOwn(record, "responseSchema");
-  if (record === undefined || !exactKeys(record, hasSchema ? ["apiKey", "baseURL", "instructions", "model", "protocol", "responseSchema"] : ["apiKey", "baseURL", "instructions", "model", "protocol"]) || record.protocol !== PRIVATE_OPENROUTER_RESPONSES_PROTOCOL || typeof record.apiKey !== "string" || record.apiKey.trim().length === 0 || record.apiKey.includes("\x00") || new TextEncoder().encode(record.apiKey).byteLength > 16384 || record.baseURL !== PRIVATE_OPENROUTER_RESPONSES_BASE_URL || record.model !== PRIVATE_OPENROUTER_RESPONSES_MODEL || typeof record.instructions !== "string" || !boundedCharacters(record.instructions, MAX_INSTRUCTION_CHARACTERS) || hasSchema && ordinaryRecord(record.responseSchema) === undefined) {
-    throw protocolFailure("OpenRouter Responses worker request has an invalid shape");
+  if (record === undefined || !exactKeys(record, hasSchema ? ["apiKey", "baseURL", "instructions", "model", "protocol", "responseSchema"] : ["apiKey", "baseURL", "instructions", "model", "protocol"]) || record.protocol !== PRIVATE_OPENAI_RESPONSES_PROTOCOL || typeof record.apiKey !== "string" || record.apiKey.trim().length === 0 || record.apiKey.includes("\x00") || new TextEncoder().encode(record.apiKey).byteLength > 16384 || !validBaseURL(record.baseURL) || !validModel(record.model) || typeof record.instructions !== "string" || !boundedCharacters(record.instructions, MAX_INSTRUCTION_CHARACTERS) || hasSchema && ordinaryRecord(record.responseSchema) === undefined) {
+    throw protocolFailure("OpenAI Responses worker request has an invalid shape");
   }
   if (hasSchema) {
     const responseSchema = record.responseSchema;
@@ -13985,39 +13983,39 @@ function requirePrivateOpenRouterResponsesRequest(value) {
     try {
       schemaBytes = canonicalJson(responseSchema);
     } catch {
-      throw protocolFailure("OpenRouter Responses response schema is not valid JSON/1");
+      throw protocolFailure("OpenAI Responses response schema is not valid JSON/1");
     }
     if (schemaBytes.byteLength > MAX_RESPONSE_SCHEMA_BYTES) {
-      throw protocolFailure("OpenRouter Responses response schema exceeds its byte bound");
+      throw protocolFailure("OpenAI Responses response schema exceeds its byte bound");
     }
     return Object.freeze({
-      protocol: PRIVATE_OPENROUTER_RESPONSES_PROTOCOL,
+      protocol: PRIVATE_OPENAI_RESPONSES_PROTOCOL,
       apiKey: record.apiKey,
-      baseURL: PRIVATE_OPENROUTER_RESPONSES_BASE_URL,
-      model: PRIVATE_OPENROUTER_RESPONSES_MODEL,
+      baseURL: record.baseURL,
+      model: record.model,
       instructions: record.instructions,
       responseSchema
     });
   }
   return Object.freeze({
-    protocol: PRIVATE_OPENROUTER_RESPONSES_PROTOCOL,
+    protocol: PRIVATE_OPENAI_RESPONSES_PROTOCOL,
     apiKey: record.apiKey,
-    baseURL: PRIVATE_OPENROUTER_RESPONSES_BASE_URL,
-    model: PRIVATE_OPENROUTER_RESPONSES_MODEL,
+    baseURL: record.baseURL,
+    model: record.model,
     instructions: record.instructions
   });
 }
-function requirePrivateOpenRouterResponsesResult(value) {
+function requirePrivateOpenAIResponsesResult(value) {
   const record = ordinaryRecord(value);
   const hasStructured = record !== undefined && Object.hasOwn(record, "structured");
   if (record === undefined || !exactKeys(record, hasStructured ? ["outcome", "structured", "text"] : ["outcome", "text"]) || record.outcome !== "completed" && record.outcome !== "blocked" && record.outcome !== "limit" || typeof record.text !== "string" || new TextEncoder().encode(record.text).byteLength > JSON_1_LIMITS.stringBytes) {
-    throw protocolFailure("OpenRouter Responses worker result has an invalid shape");
+    throw protocolFailure("OpenAI Responses worker result has an invalid shape");
   }
   if (hasStructured) {
     try {
       validateJson1(record.structured);
     } catch {
-      throw protocolFailure("OpenRouter Responses worker structured result is not JSON/1");
+      throw protocolFailure("OpenAI Responses worker structured result is not JSON/1");
     }
     return Object.freeze({
       outcome: record.outcome,
@@ -14032,10 +14030,10 @@ function encodeBounded(value, maximum, code, message) {
   try {
     bytes = canonicalJson(value);
   } catch {
-    throw new PrivateOpenRouterResponsesError(code, message);
+    throw new PrivateOpenAIResponsesError(code, message);
   }
   if (bytes.byteLength > maximum) {
-    throw new PrivateOpenRouterResponsesError(code, message);
+    throw new PrivateOpenAIResponsesError(code, message);
   }
   return bytes;
 }
@@ -14062,6 +14060,19 @@ function boundedCharacters(value, maximum) {
   }
   return true;
 }
+function validBaseURL(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 4096)
+    return false;
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "https:" && parsed.username === "" && parsed.password === "" && parsed.search === "" && parsed.hash === "";
+  } catch {
+    return false;
+  }
+}
+function validModel(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/.test(value);
+}
 function boundUtf8(value, maximum) {
   if (new TextEncoder().encode(value).byteLength <= maximum)
     return value;
@@ -14077,19 +14088,122 @@ function boundUtf8(value, maximum) {
   return result;
 }
 function protocolFailure(message) {
-  return new PrivateOpenRouterResponsesError("AGENT_PROVIDER_PROTOCOL", message);
+  return new PrivateOpenAIResponsesError("AGENT_PROVIDER_PROTOCOL", message);
 }
 
-// src/internal/openrouter-responses-client.ts
+// src/internal/openai-responses-client.ts
 var MAX_INSTRUCTION_CHARACTERS2 = 1048576;
 var MAX_RESPONSE_SCHEMA_BYTES2 = 256 * 1024;
 var RESPONSE_FORMAT_NAME = "jig_agent_run_result";
 var MAX_OUTPUT_TOKENS = 4096;
-async function requestPrivateOpenRouterResponse(request, dependencies) {
-  requireClientRequest(request, dependencies.client !== undefined || dependencies.fetch !== undefined);
+var MAX_RESPONSE_SCHEMA_DEPTH = 8;
+var MAX_PROPERTIES_PER_OBJECT = 32;
+var MAX_RESPONSE_SCHEMA_PROPERTIES = 128;
+var MAX_ARRAY_ITEMS = 256;
+var MAX_RESPONSE_SCHEMA_ENUM_VALUES = 256;
+var MAX_RESPONSE_SCHEMA_SYMBOL_CHARACTERS = 120000;
+var MAX_LARGE_ENUM_CHARACTERS = 15000;
+function assertPrivateAgentResponseSchema(schema) {
+  if (schema.$schema !== "https://flow.jig.md/schemas/schema-1.json")
+    invalidSchemaProfile();
+  const state2 = {
+    properties: 0,
+    enumValues: 0,
+    symbolCharacters: 0
+  };
+  assertResponseSchemaNode(schema, 1, true, state2);
+}
+function assertResponseSchemaNode(value, depth, root, state2) {
+  const schema = ordinaryRecord2(value);
+  if (schema === undefined || depth > MAX_RESPONSE_SCHEMA_DEPTH)
+    invalidSchemaProfile();
+  if (schema.type === "object") {
+    assertClosedResponseObject(schema, depth, root, state2);
+    return;
+  }
+  if (root || Object.hasOwn(schema, "$schema"))
+    invalidSchemaProfile();
+  if (schema.type === "array") {
+    const baseExpected = Object.hasOwn(schema, "minItems") ? ["items", "maxItems", "minItems", "type"] : ["items", "maxItems", "type"];
+    if (!exactProfileKeys(schema, baseExpected) || !boundedNonnegativeInteger(schema.maxItems, MAX_ARRAY_ITEMS) || Object.hasOwn(schema, "minItems") && (!boundedNonnegativeInteger(schema.minItems, MAX_ARRAY_ITEMS) || schema.minItems > schema.maxItems)) {
+      invalidSchemaProfile();
+    }
+    assertResponseSchemaNode(schema.items, depth + 1, false, state2);
+    return;
+  }
+  if (schema.type === "integer" || isNullableType(schema.type, "integer")) {
+    if (!exactProfileKeys(schema, ["type"]))
+      invalidSchemaProfile();
+    return;
+  }
+  if (schema.type === "string" || isNullableType(schema.type, "string")) {
+    assertResponseString(schema, isNullableType(schema.type, "string"), state2);
+    return;
+  }
+  invalidSchemaProfile();
+}
+function assertClosedResponseObject(schema, depth, root, state2) {
+  const expected = root ? ["$schema", "additionalProperties", "properties", "required", "type"] : ["additionalProperties", "properties", "required", "type"];
+  const properties = ordinaryRecord2(schema.properties);
+  if (!exactProfileKeys(schema, expected) || schema.additionalProperties !== false || properties === undefined || !Array.isArray(schema.required)) {
+    invalidSchemaProfile();
+  }
+  const names = Object.keys(properties);
+  if (names.length === 0 || names.length > MAX_PROPERTIES_PER_OBJECT || schema.required.length !== names.length || new Set(schema.required).size !== names.length || schema.required.some((name) => typeof name !== "string" || !Object.hasOwn(properties, name))) {
+    invalidSchemaProfile();
+  }
+  state2.properties += names.length;
+  if (state2.properties > MAX_RESPONSE_SCHEMA_PROPERTIES)
+    invalidSchemaProfile();
+  for (const name of names) {
+    state2.symbolCharacters += unicodeScalarLength(name);
+    if (state2.symbolCharacters > MAX_RESPONSE_SCHEMA_SYMBOL_CHARACTERS)
+      invalidSchemaProfile();
+    assertResponseSchemaNode(properties[name], depth + 1, false, state2);
+  }
+}
+function assertResponseString(schema, nullable, state2) {
+  if (!Object.hasOwn(schema, "enum")) {
+    if (!exactProfileKeys(schema, ["type"]))
+      invalidSchemaProfile();
+    return;
+  }
+  if (!exactProfileKeys(schema, ["enum", "type"]) || !Array.isArray(schema.enum) || schema.enum.length === 0 || schema.enum.length > MAX_RESPONSE_SCHEMA_ENUM_VALUES || schema.enum.some((item) => typeof item !== "string" && (!nullable || item !== null)) || new Set(schema.enum).size !== schema.enum.length || nullable && (!schema.enum.includes(null) || !schema.enum.some((item) => typeof item === "string"))) {
+    invalidSchemaProfile();
+  }
+  state2.enumValues += schema.enum.length;
+  const enumCharacters = schema.enum.reduce((total, item) => total + (typeof item === "string" ? unicodeScalarLength(item) : 0), 0);
+  if (schema.enum.length > 250 && enumCharacters > MAX_LARGE_ENUM_CHARACTERS) {
+    invalidSchemaProfile();
+  }
+  state2.symbolCharacters += enumCharacters;
+  if (state2.enumValues > MAX_RESPONSE_SCHEMA_ENUM_VALUES)
+    invalidSchemaProfile();
+  if (state2.symbolCharacters > MAX_RESPONSE_SCHEMA_SYMBOL_CHARACTERS)
+    invalidSchemaProfile();
+}
+function isNullableType(value, base) {
+  return Array.isArray(value) && value.length === 2 && new Set(value).size === 2 && value.includes(base) && value.includes("null");
+}
+function exactProfileKeys(value, expected) {
+  if (Object.hasOwn(value, "description") && typeof value.description !== "string")
+    return false;
+  return exactKeys2(value, Object.hasOwn(value, "description") ? [...expected, "description"] : expected);
+}
+function boundedNonnegativeInteger(value, maximum) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= maximum;
+}
+function unicodeScalarLength(value) {
+  return [...value].length;
+}
+function invalidSchemaProfile() {
+  throw new TypeError("Agent responseSchema must use the bounded structured-output profile");
+}
+async function requestPrivateOpenAIResponse(request, dependencies) {
+  requireClientRequest(request);
   requireApiKey(dependencies.apiKey);
   if (dependencies.client !== undefined && dependencies.fetch !== undefined) {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenRouter Responses test transport is ambiguous");
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI Responses test transport is ambiguous");
   }
   const body = createBody(request);
   const client = dependencies.client ?? sdkClient(request.baseURL, dependencies.apiKey, dependencies.fetch);
@@ -14097,17 +14211,17 @@ async function requestPrivateOpenRouterResponse(request, dependencies) {
   try {
     response = await client.create(body);
   } catch {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_UNAVAILABLE", "OpenRouter Responses request failed");
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_UNAVAILABLE", "OpenAI Responses request failed");
   }
-  return normalizePrivateOpenRouterResponse(response, request.responseSchema !== undefined);
+  return normalizePrivateOpenAIResponse(response, request.responseSchema !== undefined);
 }
-function normalizePrivateOpenRouterResponse(response, structuredRequested) {
+function normalizePrivateOpenAIResponse(response, structuredRequested) {
   const record = ordinaryRecord2(response);
   if (record === undefined || record.status !== "completed" && record.status !== "incomplete" && record.status !== "failed" && record.status !== "cancelled" && record.status !== "queued" && record.status !== "in_progress" || !Array.isArray(record.output)) {
     throw invalidResponse();
   }
   if (Object.hasOwn(record, "error") && record.error !== null || record.status === "failed" || record.status === "cancelled") {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_UNAVAILABLE", "OpenRouter Responses request did not complete");
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_UNAVAILABLE", "OpenAI Responses request did not complete");
   }
   if (record.status === "queued" || record.status === "in_progress") {
     throw invalidResponse();
@@ -14132,7 +14246,7 @@ function normalizePrivateOpenRouterResponse(response, structuredRequested) {
   } catch {
     if (outcome !== "completed")
       return Object.freeze({ outcome, text });
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_RESPONSE_INVALID", "OpenRouter structured response is not valid JSON/1");
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_RESPONSE_INVALID", "OpenAI structured response is not valid JSON/1");
   }
 }
 function sdkClient(baseURL, apiKey, injectedFetch) {
@@ -14176,44 +14290,46 @@ function createBody(request) {
       format: {
         type: "json_schema",
         name: RESPONSE_FORMAT_NAME,
-        schema: providerSchema(request.responseSchema),
+        schema: projectPrivateAgentResponseSchema(request.responseSchema),
         strict: true
       }
     }
   };
 }
-function providerSchema(responseSchema) {
+function projectPrivateAgentResponseSchema(responseSchema) {
   return Object.fromEntries(Object.entries(responseSchema).filter(([name]) => name !== "$schema"));
 }
-function requireClientRequest(request, injectedTransport) {
+function requireClientRequest(request) {
   if (request === null || typeof request !== "object" || typeof request.baseURL !== "string" || typeof request.model !== "string" || typeof request.instructions !== "string" || !boundedCharacters2(request.instructions, MAX_INSTRUCTION_CHARACTERS2)) {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenRouter Responses client request is invalid");
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI Responses client request is invalid");
   }
   try {
     validateJson1(request.instructions);
   } catch {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenRouter Responses instructions are not valid JSON/1 text");
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI Responses instructions are not valid JSON/1 text");
   }
   requireEndpoint(request.baseURL);
   if (!/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/.test(request.model)) {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenRouter Responses model is invalid");
-  }
-  if (!injectedTransport && (request.baseURL !== PRIVATE_OPENROUTER_RESPONSES_BASE_URL || request.model !== PRIVATE_OPENROUTER_RESPONSES_MODEL)) {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenRouter Responses production configuration is not pinned");
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI Responses model is invalid");
   }
   if (request.responseSchema !== undefined) {
     if (ordinaryRecord2(request.responseSchema) === undefined) {
-      throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenRouter response schema is invalid");
+      throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI response schema is invalid");
     }
     let bytes;
     try {
       validateJson1(request.responseSchema);
       bytes = canonicalJson(request.responseSchema);
     } catch {
-      throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenRouter response schema is not valid JSON/1");
+      throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI response schema is not valid JSON/1");
     }
     if (bytes.byteLength > MAX_RESPONSE_SCHEMA_BYTES2) {
-      throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenRouter response schema exceeds its byte bound");
+      throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI response schema exceeds its byte bound");
+    }
+    try {
+      assertPrivateAgentResponseSchema(request.responseSchema);
+    } catch {
+      throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI response schema is outside the supported profile");
     }
   }
 }
@@ -14227,16 +14343,16 @@ function requireEndpoint(baseURL) {
   } catch {
     throw invalidEndpoint();
   }
-  if (parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username !== "" || parsed.password !== "" || parsed.search !== "" || parsed.hash !== "") {
+  if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || parsed.search !== "" || parsed.hash !== "") {
     throw invalidEndpoint();
   }
 }
 function invalidEndpoint() {
-  return new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenRouter Responses base URL is invalid");
+  return new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI Responses base URL is invalid");
 }
 function requireApiKey(apiKey) {
   if (typeof apiKey !== "string" || apiKey.trim().length === 0 || apiKey.includes("\x00") || new TextEncoder().encode(apiKey).byteLength > 16384) {
-    throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_CONFIGURATION", "OPENROUTER_API_KEY is unavailable");
+    throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_CONFIGURATION", "OpenAI Responses API key is unavailable");
   }
 }
 function responseContent(record, allowEmpty) {
@@ -14285,7 +14401,7 @@ function joinBounded(parts, separator) {
     if (index !== 0)
       bytes += separatorBytes;
     if (bytes > JSON_1_LIMITS.stringBytes) {
-      throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_OUTPUT_LIMIT", "OpenRouter Responses text exceeds its byte bound");
+      throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_OUTPUT_LIMIT", "OpenAI Responses text exceeds its byte bound");
     }
   }
   return parts.join(separator);
@@ -14298,6 +14414,11 @@ function ordinaryRecord2(value) {
     return;
   return value;
 }
+function exactKeys2(value, expected) {
+  const actual = Object.keys(value).sort();
+  const sorted = [...expected].sort();
+  return actual.length === sorted.length && actual.every((name, index) => name === sorted[index]);
+}
 function boundedCharacters2(value, maximum) {
   if (value.length === 0)
     return false;
@@ -14310,23 +14431,23 @@ function boundedCharacters2(value, maximum) {
   return true;
 }
 function invalidResponse() {
-  return new PrivateOpenRouterResponsesError("AGENT_PROVIDER_RESPONSE_INVALID", "OpenRouter Responses returned an invalid final response");
+  return new PrivateOpenAIResponsesError("AGENT_PROVIDER_RESPONSE_INVALID", "OpenAI Responses returned an invalid final response");
 }
 
-// src/internal/openrouter-responses-worker.ts
+// src/internal/openai-responses-worker.ts
 await main();
 async function main() {
   let output;
   try {
-    const input = await readBoundedInput(PRIVATE_OPENROUTER_RESPONSES_REQUEST_BYTES);
-    const request = decodePrivateOpenRouterResponsesRequest(input);
-    const value = await requestPrivateOpenRouterResponse(request, {
+    const input = await readBoundedInput(PRIVATE_OPENAI_RESPONSES_REQUEST_BYTES);
+    const request = decodePrivateOpenAIResponsesRequest(input);
+    const value = await requestPrivateOpenAIResponse(request, {
       apiKey: request.apiKey
     });
-    output = encodePrivateOpenRouterResponsesSuccess(value);
+    output = encodePrivateOpenAIResponsesSuccess(value);
   } catch (error2) {
     const failure = safeFailure(error2);
-    output = encodePrivateOpenRouterResponsesFailure(failure.code, failure.message);
+    output = encodePrivateOpenAIResponsesFailure(failure.code, failure.message);
   }
   try {
     await writeOutput(output);
@@ -14341,7 +14462,7 @@ async function readBoundedInput(maximum) {
     const chunk = typeof raw === "string" ? new TextEncoder().encode(raw) : new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength);
     total += chunk.byteLength;
     if (total > maximum) {
-      throw new PrivateOpenRouterResponsesError("AGENT_PROVIDER_PROTOCOL", "OpenRouter Responses worker request exceeds its byte bound");
+      throw new PrivateOpenAIResponsesError("AGENT_PROVIDER_PROTOCOL", "OpenAI Responses worker request exceeds its byte bound");
     }
     chunks.push(chunk.slice());
   }
@@ -14354,12 +14475,12 @@ async function readBoundedInput(maximum) {
   return result;
 }
 function safeFailure(error2) {
-  if (error2 instanceof PrivateOpenRouterResponsesError) {
+  if (error2 instanceof PrivateOpenAIResponsesError) {
     return Object.freeze({ code: error2.code, message: error2.message });
   }
   return Object.freeze({
     code: "AGENT_PROVIDER_UNAVAILABLE",
-    message: "OpenRouter Responses worker failed"
+    message: "OpenAI Responses worker failed"
   });
 }
 function writeOutput(bytes) {

package/libexec/agent/pi-acp.LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sergii Kozak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.