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

package/README.md

@@ -15,7 +15,7 @@ authority they need or fail closed.
 ## Install
 
 ```console
-npm install --global @jigging/jig@0.1.0-alpha.6
+npm install --global @jigging/jig@0.1.0-alpha.7
 ```
 
 Installing Jig also installs `@oven/bun-linux-x64-baseline@1.3.3` as an exact

package/libexec/agent/openai-responses-worker.js

@@ -14096,6 +14096,109 @@ 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;
+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);
@@ -14187,13 +14290,13 @@ function createBody(request) {
       format: {
         type: "json_schema",
         name: RESPONSE_FORMAT_NAME,
-        schema: openAIResponseSchema(request.responseSchema),
+        schema: projectPrivateAgentResponseSchema(request.responseSchema),
         strict: true
       }
     }
   };
 }
-function openAIResponseSchema(responseSchema) {
+function projectPrivateAgentResponseSchema(responseSchema) {
   return Object.fromEntries(Object.entries(responseSchema).filter(([name]) => name !== "$schema"));
 }
 function requireClientRequest(request) {
@@ -14223,6 +14326,11 @@ function requireClientRequest(request) {
     if (bytes.byteLength > MAX_RESPONSE_SCHEMA_BYTES2) {
       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");
+    }
   }
 }
 function requireEndpoint(baseURL) {
@@ -14306,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;

package/libexec/installed-cli.js

@@ -58797,23 +58797,108 @@ function protocolFailure2(message) {
 
 // src/internal/openai-responses-client.ts
 var MAX_RESPONSE_SCHEMA_BYTES2 = 256 * 1024;
-var MAX_ENUM_PROPERTIES = 32;
-var MAX_ENUM_VALUES = 256;
+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 (!exactKeys5(schema, ["$schema", "additionalProperties", "properties", "required", "type"]) || schema.$schema !== "https://flow.jig.md/schemas/schema-1.json" || schema.type !== "object" || schema.additionalProperties !== false || ordinaryRecord4(schema.properties) === undefined || !Array.isArray(schema.required)) {
-    throw new TypeError("Agent responseSchema must be one closed enum object");
+  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 = ordinaryRecord4(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 = ordinaryRecord4(schema.properties);
+  if (!exactProfileKeys(schema, expected) || schema.additionalProperties !== false || properties === undefined || !Array.isArray(schema.required)) {
+    invalidSchemaProfile();
   }
-  const properties = schema.properties;
   const names = Object.keys(properties);
-  if (names.length === 0 || names.length > MAX_ENUM_PROPERTIES || schema.required.length !== names.length || new Set(schema.required).size !== names.length || schema.required.some((name) => typeof name !== "string" || !Object.hasOwn(properties, name))) {
-    throw new TypeError("Agent responseSchema must require every enum property");
+  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();
   }
-  for (const value of Object.values(properties)) {
-    const property = ordinaryRecord4(value);
-    if (property === undefined || !exactKeys5(property, ["enum"]) || !Array.isArray(property.enum) || property.enum.length === 0 || property.enum.length > MAX_ENUM_VALUES || property.enum.some((item) => typeof item !== "string") || new Set(property.enum).size !== property.enum.length) {
-      throw new TypeError("Agent responseSchema properties must be string enums");
-    }
+  state2.properties += names.length;
+  if (state2.properties > MAX_RESPONSE_SCHEMA_PROPERTIES)
+    invalidSchemaProfile();
+  for (const name of names) {
+    state2.symbolCharacters += unicodeScalarLength2(name);
+    if (state2.symbolCharacters > MAX_RESPONSE_SCHEMA_SYMBOL_CHARACTERS)
+      invalidSchemaProfile();
+    assertResponseSchemaNode(properties[name], depth + 1, false, state2);
+  }
+}
+function assertResponseString(schema, nullable2, 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" && (!nullable2 || item !== null)) || new Set(schema.enum).size !== schema.enum.length || nullable2 && (!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" ? unicodeScalarLength2(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 exactKeys5(value, Object.hasOwn(value, "description") ? [...expected, "description"] : expected);
+}
+function boundedNonnegativeInteger(value, maximum) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= maximum;
+}
+function unicodeScalarLength2(value) {
+  return [...value].length;
+}
+function invalidSchemaProfile() {
+  throw new TypeError("Agent responseSchema must use the bounded structured-output profile");
 }
 var SILENT_LOGGER = Object.freeze({
   error() {},
@@ -58821,6 +58906,9 @@ var SILENT_LOGGER = Object.freeze({
   info() {},
   debug() {}
 });
+function projectPrivateAgentResponseSchema(responseSchema) {
+  return Object.fromEntries(Object.entries(responseSchema).filter(([name]) => name !== "$schema"));
+}
 function ordinaryRecord4(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     return;
@@ -59092,10 +59180,11 @@ function renderPrivateAgentRunInstructions(instructions, manifest) {
   return rendered;
 }
 function renderPrivateAcpStructuredInstructions(instructions, responseSchema) {
-  const schema = decoder10.decode(canonicalJson(responseSchema));
+  const schema = decoder10.decode(canonicalJson(projectPrivateAgentResponseSchema(responseSchema)));
   const rendered = [
     instructions,
     "Return only one JSON value matching this canonical FLOW Schema/1 schema:",
+    "Do not wrap the JSON value in Markdown or a code fence.",
     schema
   ].join(`
 `);
@@ -59316,9 +59405,19 @@ function acpResultValue(turn, structuredRequested) {
   return Object.freeze({
     outcome,
     text: turn.text,
-    structured: decodeJson1(encoder11.encode(turn.text))
+    structured: decodePrivateAcpStructuredText(turn.text)
   });
 }
+function decodePrivateAcpStructuredText(text) {
+  try {
+    return decodeJson1(encoder11.encode(text));
+  } catch (rawError) {
+    const match = /^```json\r?\n([\s\S]*)\r?\n```$/.exec(text.trim());
+    if (match === null)
+      throw rawError;
+    return decodeJson1(encoder11.encode(match[1]));
+  }
+}
 async function releaseKnownAgent(input, lifecycleValue, fence) {
   let lifecycle = lifecycleValue;
   const sandbox = parseSandbox2(lifecycle);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jigging/jig",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "description": "A local, secure host for admitted FLOW packages",
   "license": "MPL-2.0",
   "repository": {