@finalai/final-agent-provider 0.10.0 → 0.11.0

package/dist/modules/harnesses/adapters.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/harnesses/adapters.ts"],
+  "sourcesContent": ["import { defineAcpAdapter } from '@finalai/agent-definition/authoring';\nimport { FinalExtension, type AcpAdapterDefinitionIface } from '@finalai/agent-provider';\nimport { REQUIRED_FINAL_EXTENSIONS } from \"../provider/general.mjs\";\nimport { FinalAcpAdapter, FinalHarnessInterface } from \"./names.mjs\";\n\n// Final's ACP adapters. Each implements ACP v2 and Final's ACP extensions and\n// advertises them in `initialize`; the general harness provider refuses an\n// adapter that does not (../provider/general.ts). Fork is optional.\n\n// The worker runtime's engines that map a harness program to ACP v2. The\n// worker program started is the engine; the harness's own program comes in\n// its input (`{ harness: { program }, configuration }`).\nexport const PI_ACP_ADAPTER: AcpAdapterDefinitionIface = defineAcpAdapter({\n  title: 'Pi ACP adapter',\n  description: 'Maps the Pi agent loop (Pi and the Final harness) to ACP v2 on a worker runtime.',\n  adapts: [FinalHarnessInterface.PiAgent],\n  run: { worker: { program: 'pi' } },\n  extensions: [...REQUIRED_FINAL_EXTENSIONS],\n});\n\nexport const NANOCODE_ACP_ADAPTER: AcpAdapterDefinitionIface = defineAcpAdapter({\n  title: 'nanocode ACP adapter',\n  description: \"Maps nanocode's Claude and Codex engines to ACP v2 on a worker runtime.\",\n  adapts: [FinalHarnessInterface.Nanocode],\n  run: { worker: { program: 'nanocode' } },\n  extensions: [...REQUIRED_FINAL_EXTENSIONS],\n});\n\n// The process adapters are published packages. Each takes the harness's\n// command line after `--` and launches it as the program it adapts; the\n// permission level is Final's (`ask`, `review`, `auto`), mapped by the\n// adapter onto the program's own modes.\nconst permissionArgs = {\n  when: 'configuration.permissionMode',\n  args: ['--permission-mode', '{{configuration.permissionMode}}'],\n};\n\nexport const CLAUDE_CODE_ACP_ADAPTER: AcpAdapterDefinitionIface = defineAcpAdapter({\n  title: 'Claude Code ACP adapter',\n  description: 'Runs Claude Code through the Claude Agent SDK and speaks ACP v2 on stdio.',\n  adapts: [FinalHarnessInterface.ClaudeAgentSdk],\n  run: {\n    process: {\n      command: 'npx',\n      args: [\n        '-y',\n        '@finalai/acp-adapter-claude-code',\n        permissionArgs,\n        '--',\n        '{{harness.command}}',\n        { spread: 'harness.args' },\n      ],\n    },\n  },\n  extensions: [...REQUIRED_FINAL_EXTENSIONS, FinalExtension.Fork],\n});\n\nexport const CODEX_ACP_ADAPTER: AcpAdapterDefinitionIface = defineAcpAdapter({\n  title: 'Codex ACP adapter',\n  description: 'Runs the Codex app-server and speaks ACP v2 on stdio.',\n  adapts: [FinalHarnessInterface.CodexAppServer],\n  run: {\n    process: {\n      command: 'npx',\n      args: [\n        '-y',\n        '@finalai/acp-adapter-codex',\n        permissionArgs,\n        '--',\n        '{{harness.command}}',\n        { spread: 'harness.args' },\n      ],\n    },\n  },\n  extensions: [...REQUIRED_FINAL_EXTENSIONS],\n});\n\nexport const FINAL_ACP_ADAPTERS: Record<FinalAcpAdapter, AcpAdapterDefinitionIface> = {\n  [FinalAcpAdapter.Pi]: PI_ACP_ADAPTER,\n  [FinalAcpAdapter.Nanocode]: NANOCODE_ACP_ADAPTER,\n  [FinalAcpAdapter.ClaudeCode]: CLAUDE_CODE_ACP_ADAPTER,\n  [FinalAcpAdapter.Codex]: CODEX_ACP_ADAPTER,\n};\n"],
+  "mappings": "AAAA,SAAS,wBAAwB;AACjC,SAAS,sBAAsD;AAC/D,SAAS,iCAAiC;AAC1C,SAAS,iBAAiB,6BAA6B;AAShD,MAAM,iBAA4C,iBAAiB;AAAA,EACxE,OAAO;AAAA,EACP,aAAa;AAAA,EACb,QAAQ,CAAC,sBAAsB,OAAO;AAAA,EACtC,KAAK,EAAE,QAAQ,EAAE,SAAS,KAAK,EAAE;AAAA,EACjC,YAAY,CAAC,GAAG,yBAAyB;AAC3C,CAAC;AAEM,MAAM,uBAAkD,iBAAiB;AAAA,EAC9E,OAAO;AAAA,EACP,aAAa;AAAA,EACb,QAAQ,CAAC,sBAAsB,QAAQ;AAAA,EACvC,KAAK,EAAE,QAAQ,EAAE,SAAS,WAAW,EAAE;AAAA,EACvC,YAAY,CAAC,GAAG,yBAAyB;AAC3C,CAAC;AAMD,MAAM,iBAAiB;AAAA,EACrB,MAAM;AAAA,EACN,MAAM,CAAC,qBAAqB,kCAAkC;AAChE;AAEO,MAAM,0BAAqD,iBAAiB;AAAA,EACjF,OAAO;AAAA,EACP,aAAa;AAAA,EACb,QAAQ,CAAC,sBAAsB,cAAc;AAAA,EAC7C,KAAK;AAAA,IACH,SAAS;AAAA,MACP,SAAS;AAAA,MACT,MAAM;AAAA,QACJ;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,EAAE,QAAQ,eAAe;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AAAA,EACA,YAAY,CAAC,GAAG,2BAA2B,eAAe,IAAI;AAChE,CAAC;AAEM,MAAM,oBAA+C,iBAAiB;AAAA,EAC3E,OAAO;AAAA,EACP,aAAa;AAAA,EACb,QAAQ,CAAC,sBAAsB,cAAc;AAAA,EAC7C,KAAK;AAAA,IACH,SAAS;AAAA,MACP,SAAS;AAAA,MACT,MAAM;AAAA,QACJ;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,EAAE,QAAQ,eAAe;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AAAA,EACA,YAAY,CAAC,GAAG,yBAAyB;AAC3C,CAAC;AAEM,MAAM,qBAAyE;AAAA,EACpF,CAAC,gBAAgB,EAAE,GAAG;AAAA,EACtB,CAAC,gBAAgB,QAAQ,GAAG;AAAA,EAC5B,CAAC,gBAAgB,UAAU,GAAG;AAAA,EAC9B,CAAC,gBAAgB,KAAK,GAAG;AAC3B;",
+  "names": []
+}

package/dist/modules/harnesses/claude-code.d.mts

@@ -0,0 +1,14 @@
+import { type HarnessDefinitionIface, type HarnessEnvironmentIface, type HarnessSettingsIface } from '@finalai/agent-provider';
+import { type InferenceInput, type PermissionInput } from "./config-fields.mjs";
+export declare const CLAUDE_CODE_NATIVE_TOOLS: {
+    files: string[];
+    shell: string[];
+};
+export declare const CLAUDE_CODE_HARNESS: HarnessDefinitionIface;
+export interface ClaudeCodeInputIface {
+    model?: string;
+    inference?: InferenceInput;
+    permissionMode?: PermissionInput;
+    environment?: HarnessEnvironmentIface;
+}
+export declare const claudeCode: ({ environment, ...configuration }?: ClaudeCodeInputIface) => HarnessSettingsIface;

package/dist/modules/harnesses/claude-code.mjs

@@ -0,0 +1,79 @@
+import { defineHarness } from "@finalai/agent-definition/authoring";
+import {
+  CredentialDelivery,
+  HarnessFeature,
+  InferenceSourceKind,
+  McpTransportKind,
+  PermissionLevel,
+  PromptWhileRunning,
+  SandboxWire
+} from "@finalai/agent-provider";
+import {
+  configObjectJson,
+  harnessSettings,
+  inferenceJson,
+  permissionModeJson
+} from "./config-fields.mjs";
+import { ModelVendor } from "./model-reference.mjs";
+import { FinalAcpAdapter, FinalHarness, FinalHarnessInterface } from "./names.mjs";
+const CLAUDE_CODE_NATIVE_TOOLS = {
+  files: ["Read", "Write", "Edit", "Glob", "Grep", "NotebookEdit"],
+  shell: ["Bash", "BashOutput", "KillShell"]
+};
+const CLAUDE_CODE_HARNESS = defineHarness({
+  title: "Claude Code",
+  description: "Claude Code, run as a process on the machine it works on.",
+  configurationSchema: configObjectJson({
+    title: "Claude Code",
+    properties: {
+      model: { $ref: "final://schemas/model-picker", type: "string", minLength: 1 },
+      inference: inferenceJson(),
+      permissionMode: permissionModeJson()
+    }
+  }),
+  // Claude Code takes no skills, and its allow-lists cannot carry an agent's
+  // per-tool approvals.
+  features: [HarnessFeature.McpTools, HarnessFeature.SystemInstructions],
+  lowestPermission: PermissionLevel.Ask,
+  inference: {
+    vendors: [ModelVendor.Anthropic],
+    kinds: [
+      InferenceSourceKind.Harness,
+      InferenceSourceKind.Subscription,
+      InferenceSourceKind.ApiKey,
+      InferenceSourceKind.Final
+    ],
+    delivery: CredentialDelivery.AtOpen
+  },
+  native: {
+    files: { tools: CLAUDE_CODE_NATIVE_TOOLS.files },
+    shell: { tools: CLAUDE_CODE_NATIVE_TOOLS.shell }
+  },
+  interface: FinalHarnessInterface.ClaudeAgentSdk,
+  adapter: FinalAcpAdapter.ClaudeCode,
+  run: {
+    process: {
+      command: "claude",
+      args: [{ when: "configuration.model", args: ["--model", "{{configuration.model}}"] }]
+    }
+  },
+  // The adapter proxies every MCP server it is handed (acp ones over the ACP connection)
+  // and reports full tool results.
+  mcp: [McpTransportKind.Acp, McpTransportKind.Http, McpTransportKind.Stdio],
+  consumes: [SandboxWire.Mcp],
+  supports: { observe: true, resumeReplay: true, fork: true, authorMeta: true },
+  // The adapter pushes it into the running query; Claude Code takes it at its next step; one idle ends both.
+  promptWhileRunning: PromptWhileRunning.Inject,
+  // Its stdio belongs to the session service's connection to the sandbox.
+  sessionSurvivesDisconnect: false
+});
+const claudeCode = ({
+  environment,
+  ...configuration
+} = {}) => harnessSettings({ harness: FinalHarness.ClaudeCode, configuration, environment });
+export {
+  CLAUDE_CODE_HARNESS,
+  CLAUDE_CODE_NATIVE_TOOLS,
+  claudeCode
+};
+//# sourceMappingURL=claude-code.mjs.map

package/dist/modules/harnesses/claude-code.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/harnesses/claude-code.ts"],
+  "sourcesContent": ["import { defineHarness } from '@finalai/agent-definition/authoring';\nimport {\n  CredentialDelivery,\n  HarnessFeature,\n  InferenceSourceKind,\n  McpTransportKind,\n  PermissionLevel,\n  PromptWhileRunning,\n  SandboxWire,\n  type HarnessDefinitionIface,\n  type HarnessEnvironmentIface,\n  type HarnessSettingsIface,\n} from '@finalai/agent-provider';\nimport {\n  configObjectJson,\n  harnessSettings,\n  inferenceJson,\n  permissionModeJson,\n  type InferenceInput,\n  type PermissionInput,\n} from \"./config-fields.mjs\";\nimport { ModelVendor } from \"./model-reference.mjs\";\nimport { FinalAcpAdapter, FinalHarness, FinalHarnessInterface } from \"./names.mjs\";\n\n// Claude Code as a process on a machine (a computer, a device, your own host),\n// behind Final's ACP adapter on the Claude Agent SDK. Its own file and shell\n// tools work on the machine it runs on, which is therefore the sandbox\n// provided for `files` and `shell`; provided screens reach it as the sandbox\n// MCP projection.\n\nexport const CLAUDE_CODE_NATIVE_TOOLS = {\n  files: ['Read', 'Write', 'Edit', 'Glob', 'Grep', 'NotebookEdit'],\n  shell: ['Bash', 'BashOutput', 'KillShell'],\n};\n\nexport const CLAUDE_CODE_HARNESS: HarnessDefinitionIface = defineHarness({\n  title: 'Claude Code',\n  description: 'Claude Code, run as a process on the machine it works on.',\n  configurationSchema: configObjectJson({\n    title: 'Claude Code',\n    properties: {\n      model: { $ref: 'final://schemas/model-picker', type: 'string', minLength: 1 },\n      inference: inferenceJson(),\n      permissionMode: permissionModeJson(),\n    },\n  }),\n  // Claude Code takes no skills, and its allow-lists cannot carry an agent's\n  // per-tool approvals.\n  features: [HarnessFeature.McpTools, HarnessFeature.SystemInstructions],\n  lowestPermission: PermissionLevel.Ask,\n  inference: {\n    vendors: [ModelVendor.Anthropic],\n    kinds: [\n      InferenceSourceKind.Harness,\n      InferenceSourceKind.Subscription,\n      InferenceSourceKind.ApiKey,\n      InferenceSourceKind.Final,\n    ],\n    delivery: CredentialDelivery.AtOpen,\n  },\n  native: {\n    files: { tools: CLAUDE_CODE_NATIVE_TOOLS.files },\n    shell: { tools: CLAUDE_CODE_NATIVE_TOOLS.shell },\n  },\n  interface: FinalHarnessInterface.ClaudeAgentSdk,\n  adapter: FinalAcpAdapter.ClaudeCode,\n  run: {\n    process: {\n      command: 'claude',\n      args: [{ when: 'configuration.model', args: ['--model', '{{configuration.model}}'] }],\n    },\n  },\n  // The adapter proxies every MCP server it is handed (acp ones over the ACP connection)\n  // and reports full tool results.\n  mcp: [McpTransportKind.Acp, McpTransportKind.Http, McpTransportKind.Stdio],\n  consumes: [SandboxWire.Mcp],\n  supports: { observe: true, resumeReplay: true, fork: true, authorMeta: true },\n  // The adapter pushes it into the running query; Claude Code takes it at its next step; one idle ends both.\n  promptWhileRunning: PromptWhileRunning.Inject,\n  // Its stdio belongs to the session service's connection to the sandbox.\n  sessionSurvivesDisconnect: false,\n});\n\nexport interface ClaudeCodeInputIface {\n  model?: string;\n  // Absent: only the CLI's own login on the machine.\n  inference?: InferenceInput;\n  permissionMode?: PermissionInput;\n  // The sandbox it runs in (absent: the one provided for `shell`), or an ACP\n  // endpoint already running it: `atUrl({ url, hop })`.\n  environment?: HarnessEnvironmentIface;\n}\n\nexport const claudeCode = ({\n  environment,\n  ...configuration\n}: ClaudeCodeInputIface = {}): HarnessSettingsIface =>\n  harnessSettings({ harness: FinalHarness.ClaudeCode, configuration, environment });\n"],
+  "mappings": "AAAA,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP,SAAS,mBAAmB;AAC5B,SAAS,iBAAiB,cAAc,6BAA6B;AAQ9D,MAAM,2BAA2B;AAAA,EACtC,OAAO,CAAC,QAAQ,SAAS,QAAQ,QAAQ,QAAQ,cAAc;AAAA,EAC/D,OAAO,CAAC,QAAQ,cAAc,WAAW;AAC3C;AAEO,MAAM,sBAA8C,cAAc;AAAA,EACvE,OAAO;AAAA,EACP,aAAa;AAAA,EACb,qBAAqB,iBAAiB;AAAA,IACpC,OAAO;AAAA,IACP,YAAY;AAAA,MACV,OAAO,EAAE,MAAM,gCAAgC,MAAM,UAAU,WAAW,EAAE;AAAA,MAC5E,WAAW,cAAc;AAAA,MACzB,gBAAgB,mBAAmB;AAAA,IACrC;AAAA,EACF,CAAC;AAAA;AAAA;AAAA,EAGD,UAAU,CAAC,eAAe,UAAU,eAAe,kBAAkB;AAAA,EACrE,kBAAkB,gBAAgB;AAAA,EAClC,WAAW;AAAA,IACT,SAAS,CAAC,YAAY,SAAS;AAAA,IAC/B,OAAO;AAAA,MACL,oBAAoB;AAAA,MACpB,oBAAoB;AAAA,MACpB,oBAAoB;AAAA,MACpB,oBAAoB;AAAA,IACtB;AAAA,IACA,UAAU,mBAAmB;AAAA,EAC/B;AAAA,EACA,QAAQ;AAAA,IACN,OAAO,EAAE,OAAO,yBAAyB,MAAM;AAAA,IAC/C,OAAO,EAAE,OAAO,yBAAyB,MAAM;AAAA,EACjD;AAAA,EACA,WAAW,sBAAsB;AAAA,EACjC,SAAS,gBAAgB;AAAA,EACzB,KAAK;AAAA,IACH,SAAS;AAAA,MACP,SAAS;AAAA,MACT,MAAM,CAAC,EAAE,MAAM,uBAAuB,MAAM,CAAC,WAAW,yBAAyB,EAAE,CAAC;AAAA,IACtF;AAAA,EACF;AAAA;AAAA;AAAA,EAGA,KAAK,CAAC,iBAAiB,KAAK,iBAAiB,MAAM,iBAAiB,KAAK;AAAA,EACzE,UAAU,CAAC,YAAY,GAAG;AAAA,EAC1B,UAAU,EAAE,SAAS,MAAM,cAAc,MAAM,MAAM,MAAM,YAAY,KAAK;AAAA;AAAA,EAE5E,oBAAoB,mBAAmB;AAAA;AAAA,EAEvC,2BAA2B;AAC7B,CAAC;AAYM,MAAM,aAAa,CAAC;AAAA,EACzB;AAAA,EACA,GAAG;AACL,IAA0B,CAAC,MACzB,gBAAgB,EAAE,SAAS,aAAa,YAAY,eAAe,YAAY,CAAC;",
+  "names": []
+}

package/dist/modules/harnesses/codex.d.mts

@@ -0,0 +1,12 @@
+import { type HarnessDefinitionIface, type HarnessEnvironmentIface, type HarnessSettingsIface } from '@finalai/agent-provider';
+import { ReasoningLevel, type InferenceInput, type PermissionInput } from "./config-fields.mjs";
+export declare const CODEX_APP_SERVER_REASONING_LEVELS: readonly [ReasoningLevel.Minimal, ReasoningLevel.Low, ReasoningLevel.Medium, ReasoningLevel.High];
+export declare const CODEX_HARNESS: HarnessDefinitionIface;
+export interface CodexInputIface {
+    model?: string;
+    reasoning?: (typeof CODEX_APP_SERVER_REASONING_LEVELS)[number] | `${(typeof CODEX_APP_SERVER_REASONING_LEVELS)[number]}`;
+    inference?: InferenceInput;
+    permissionMode?: PermissionInput;
+    environment?: HarnessEnvironmentIface;
+}
+export declare const codex: ({ environment, ...configuration }?: CodexInputIface) => HarnessSettingsIface;

package/dist/modules/harnesses/codex.mjs

@@ -0,0 +1,90 @@
+import { defineHarness } from "@finalai/agent-definition/authoring";
+import {
+  CredentialDelivery,
+  HarnessFeature,
+  InferenceSourceKind,
+  McpTransportKind,
+  PermissionLevel,
+  PromptWhileRunning,
+  SandboxWire
+} from "@finalai/agent-provider";
+import {
+  configObjectJson,
+  harnessSettings,
+  inferenceJson,
+  permissionModeJson,
+  reasoningJson,
+  ReasoningLevel
+} from "./config-fields.mjs";
+import { ModelVendor } from "./model-reference.mjs";
+import { FinalAcpAdapter, FinalHarness, FinalHarnessInterface } from "./names.mjs";
+const CODEX_APP_SERVER_REASONING_LEVELS = [
+  ReasoningLevel.Minimal,
+  ReasoningLevel.Low,
+  ReasoningLevel.Medium,
+  ReasoningLevel.High
+];
+const CODEX_HARNESS = defineHarness({
+  title: "Codex",
+  description: "The Codex app-server, run as a process on the machine it works on.",
+  configurationSchema: configObjectJson({
+    title: "Codex",
+    properties: {
+      model: { $ref: "final://schemas/model-picker", type: "string", minLength: 1 },
+      reasoning: reasoningJson(CODEX_APP_SERVER_REASONING_LEVELS),
+      inference: inferenceJson(),
+      permissionMode: permissionModeJson()
+    }
+  }),
+  // The app-server's approvals cannot carry an agent's per-tool policy.
+  features: [HarnessFeature.Skills, HarnessFeature.McpTools, HarnessFeature.SystemInstructions],
+  lowestPermission: PermissionLevel.Ask,
+  inference: {
+    vendors: [ModelVendor.OpenAI],
+    kinds: [
+      InferenceSourceKind.Harness,
+      InferenceSourceKind.Subscription,
+      InferenceSourceKind.ApiKey,
+      InferenceSourceKind.Final
+    ],
+    delivery: CredentialDelivery.AtOpen
+  },
+  native: {
+    files: { tools: ["apply_patch"] },
+    shell: { tools: ["exec_command", "write_stdin"] }
+  },
+  interface: FinalHarnessInterface.CodexAppServer,
+  adapter: FinalAcpAdapter.Codex,
+  run: {
+    process: {
+      command: "codex",
+      args: [
+        "app-server",
+        { when: "configuration.model", args: ["-c", "model={{configuration.model}}"] },
+        {
+          when: "configuration.reasoning",
+          args: ["-c", "model_reasoning_effort={{configuration.reasoning}}"]
+        }
+      ]
+    }
+  },
+  // The adapter proxies every MCP server it is handed (acp ones over the ACP connection)
+  // and reports full tool results.
+  mcp: [McpTransportKind.Acp, McpTransportKind.Http, McpTransportKind.Stdio],
+  consumes: [SandboxWire.Mcp],
+  supports: { observe: true, resumeReplay: true, fork: true, authorMeta: true },
+  // The adapter steers it into the running turn (turn/steer); one idle ends both.
+  promptWhileRunning: PromptWhileRunning.Inject,
+  // Its stdio belongs to the session service's connection to the sandbox.
+  sessionSurvivesDisconnect: false
+});
+const codex = ({
+  environment,
+  ...configuration
+} = {}) => harnessSettings({ harness: FinalHarness.Codex, configuration, environment });
+export {
+  CODEX_APP_SERVER_REASONING_LEVELS,
+  CODEX_HARNESS,
+  codex
+};
+//# sourceMappingURL=codex.mjs.map

package/dist/modules/harnesses/codex.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/harnesses/codex.ts"],
+  "sourcesContent": ["import { defineHarness } from '@finalai/agent-definition/authoring';\nimport {\n  CredentialDelivery,\n  HarnessFeature,\n  InferenceSourceKind,\n  McpTransportKind,\n  PermissionLevel,\n  PromptWhileRunning,\n  SandboxWire,\n  type HarnessDefinitionIface,\n  type HarnessEnvironmentIface,\n  type HarnessSettingsIface,\n} from '@finalai/agent-provider';\nimport {\n  configObjectJson,\n  harnessSettings,\n  inferenceJson,\n  permissionModeJson,\n  reasoningJson,\n  ReasoningLevel,\n  type InferenceInput,\n  type PermissionInput,\n} from \"./config-fields.mjs\";\nimport { ModelVendor } from \"./model-reference.mjs\";\nimport { FinalAcpAdapter, FinalHarness, FinalHarnessInterface } from \"./names.mjs\";\n\n// The Codex app-server as a process on a machine, behind Final's ACP adapter.\n// Its own file and shell tools work on the machine it runs on, which is\n// therefore the sandbox provided for `files` and `shell`.\n\n// What the app-server takes as model_reasoning_effort.\nexport const CODEX_APP_SERVER_REASONING_LEVELS = [\n  ReasoningLevel.Minimal,\n  ReasoningLevel.Low,\n  ReasoningLevel.Medium,\n  ReasoningLevel.High,\n] as const;\n\nexport const CODEX_HARNESS: HarnessDefinitionIface = defineHarness({\n  title: 'Codex',\n  description: 'The Codex app-server, run as a process on the machine it works on.',\n  configurationSchema: configObjectJson({\n    title: 'Codex',\n    properties: {\n      model: { $ref: 'final://schemas/model-picker', type: 'string', minLength: 1 },\n      reasoning: reasoningJson(CODEX_APP_SERVER_REASONING_LEVELS),\n      inference: inferenceJson(),\n      permissionMode: permissionModeJson(),\n    },\n  }),\n  // The app-server's approvals cannot carry an agent's per-tool policy.\n  features: [HarnessFeature.Skills, HarnessFeature.McpTools, HarnessFeature.SystemInstructions],\n  lowestPermission: PermissionLevel.Ask,\n  inference: {\n    vendors: [ModelVendor.OpenAI],\n    kinds: [\n      InferenceSourceKind.Harness,\n      InferenceSourceKind.Subscription,\n      InferenceSourceKind.ApiKey,\n      InferenceSourceKind.Final,\n    ],\n    delivery: CredentialDelivery.AtOpen,\n  },\n  native: {\n    files: { tools: ['apply_patch'] },\n    shell: { tools: ['exec_command', 'write_stdin'] },\n  },\n  interface: FinalHarnessInterface.CodexAppServer,\n  adapter: FinalAcpAdapter.Codex,\n  run: {\n    process: {\n      command: 'codex',\n      args: [\n        'app-server',\n        { when: 'configuration.model', args: ['-c', 'model={{configuration.model}}'] },\n        {\n          when: 'configuration.reasoning',\n          args: ['-c', 'model_reasoning_effort={{configuration.reasoning}}'],\n        },\n      ],\n    },\n  },\n  // The adapter proxies every MCP server it is handed (acp ones over the ACP connection)\n  // and reports full tool results.\n  mcp: [McpTransportKind.Acp, McpTransportKind.Http, McpTransportKind.Stdio],\n  consumes: [SandboxWire.Mcp],\n  supports: { observe: true, resumeReplay: true, fork: true, authorMeta: true },\n  // The adapter steers it into the running turn (turn/steer); one idle ends both.\n  promptWhileRunning: PromptWhileRunning.Inject,\n  // Its stdio belongs to the session service's connection to the sandbox.\n  sessionSurvivesDisconnect: false,\n});\n\nexport interface CodexInputIface {\n  model?: string;\n  reasoning?:\n    | (typeof CODEX_APP_SERVER_REASONING_LEVELS)[number]\n    | `${(typeof CODEX_APP_SERVER_REASONING_LEVELS)[number]}`;\n  // Absent: only the CLI's own login on the machine.\n  inference?: InferenceInput;\n  permissionMode?: PermissionInput;\n  // The sandbox it runs in (absent: the one provided for `shell`), or an ACP\n  // endpoint already running it: `atUrl({ url, hop })`.\n  environment?: HarnessEnvironmentIface;\n}\n\nexport const codex = ({\n  environment,\n  ...configuration\n}: CodexInputIface = {}): HarnessSettingsIface =>\n  harnessSettings({ harness: FinalHarness.Codex, configuration, environment });\n"],
+  "mappings": "AAAA,SAAS,qBAAqB;AAC9B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAIK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AACP,SAAS,mBAAmB;AAC5B,SAAS,iBAAiB,cAAc,6BAA6B;AAO9D,MAAM,oCAAoC;AAAA,EAC/C,eAAe;AAAA,EACf,eAAe;AAAA,EACf,eAAe;AAAA,EACf,eAAe;AACjB;AAEO,MAAM,gBAAwC,cAAc;AAAA,EACjE,OAAO;AAAA,EACP,aAAa;AAAA,EACb,qBAAqB,iBAAiB;AAAA,IACpC,OAAO;AAAA,IACP,YAAY;AAAA,MACV,OAAO,EAAE,MAAM,gCAAgC,MAAM,UAAU,WAAW,EAAE;AAAA,MAC5E,WAAW,cAAc,iCAAiC;AAAA,MAC1D,WAAW,cAAc;AAAA,MACzB,gBAAgB,mBAAmB;AAAA,IACrC;AAAA,EACF,CAAC;AAAA;AAAA,EAED,UAAU,CAAC,eAAe,QAAQ,eAAe,UAAU,eAAe,kBAAkB;AAAA,EAC5F,kBAAkB,gBAAgB;AAAA,EAClC,WAAW;AAAA,IACT,SAAS,CAAC,YAAY,MAAM;AAAA,IAC5B,OAAO;AAAA,MACL,oBAAoB;AAAA,MACpB,oBAAoB;AAAA,MACpB,oBAAoB;AAAA,MACpB,oBAAoB;AAAA,IACtB;AAAA,IACA,UAAU,mBAAmB;AAAA,EAC/B;AAAA,EACA,QAAQ;AAAA,IACN,OAAO,EAAE,OAAO,CAAC,aAAa,EAAE;AAAA,IAChC,OAAO,EAAE,OAAO,CAAC,gBAAgB,aAAa,EAAE;AAAA,EAClD;AAAA,EACA,WAAW,sBAAsB;AAAA,EACjC,SAAS,gBAAgB;AAAA,EACzB,KAAK;AAAA,IACH,SAAS;AAAA,MACP,SAAS;AAAA,MACT,MAAM;AAAA,QACJ;AAAA,QACA,EAAE,MAAM,uBAAuB,MAAM,CAAC,MAAM,+BAA+B,EAAE;AAAA,QAC7E;AAAA,UACE,MAAM;AAAA,UACN,MAAM,CAAC,MAAM,oDAAoD;AAAA,QACnE;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA,EAGA,KAAK,CAAC,iBAAiB,KAAK,iBAAiB,MAAM,iBAAiB,KAAK;AAAA,EACzE,UAAU,CAAC,YAAY,GAAG;AAAA,EAC1B,UAAU,EAAE,SAAS,MAAM,cAAc,MAAM,MAAM,MAAM,YAAY,KAAK;AAAA;AAAA,EAE5E,oBAAoB,mBAAmB;AAAA;AAAA,EAEvC,2BAA2B;AAC7B,CAAC;AAeM,MAAM,QAAQ,CAAC;AAAA,EACpB;AAAA,EACA,GAAG;AACL,IAAqB,CAAC,MACpB,gBAAgB,EAAE,SAAS,aAAa,OAAO,eAAe,YAAY,CAAC;",
+  "names": []
+}

package/dist/modules/harnesses/config-fields.d.mts

@@ -1,4 +1,4 @@
-import { type CredentialPolicyIface, type DynamicSlotIface, type InstructionFragmentIface, type JsonObject, type JsonSchema, type JsonValue, type PackageProviderRefIface, type SkillBundleIface } from '@finalai/agent-provider';
+import { PermissionLevel, type HarnessSettingsIface, type InferenceSource, type JsonObject, type JsonSchema, type JsonValue, type HarnessEnvironmentIface } from '@finalai/agent-provider';
 import * as z from 'zod';
 export { MODEL_REFERENCE_PATTERN } from "./model-reference.mjs";
 export declare enum ReasoningLevel {
@@ -27,7 +27,7 @@ export declare enum CodexApprovalPolicy {
     OnFailure = "on-failure",
     Never = "never"
 }
-export declare enum CodexApprovalsReviewer {
+export declare enum ApprovalsReviewer {
     User = "user",
     AutoReview = "auto-review"
 }
@@ -39,8 +39,11 @@ export declare enum CodexSandboxMode {
 export interface SecretRefIface {
     secretKey: string;
 }
-export type InstructionInput = InstructionFragmentIface | DynamicSlotIface;
-export type SkillInput = SkillBundleIface | DynamicSlotIface;
+export type PermissionInput = PermissionLevel | `${PermissionLevel}`;
+export type InferenceInput = InferenceSource | readonly InferenceSource[];
+export declare const piPermissionModeFor: (level: PermissionLevel) => PiPermissionMode;
+export declare const claudePermissionModeFor: (level: PermissionLevel, reviewer?: ApprovalsReviewer) => ClaudePermissionMode;
+export declare const codexApprovalPolicyFor: (level: PermissionLevel) => CodexApprovalPolicy;
 export declare const configObjectJson: (args: {
     title: string;
     properties: Record<string, JsonSchema>;
@@ -48,71 +51,109 @@ export declare const configObjectJson: (args: {
 }) => JsonSchema;
 export declare const modelJson: (ids?: readonly string[], defaultId?: string) => JsonSchema;
 export declare const reasoningJson: (levels: readonly ReasoningLevel[]) => JsonSchema;
-export declare const credentialsJson: () => JsonSchema;
-export declare const permissionModeJson: (modes: readonly string[], defaultMode?: string) => JsonSchema;
-export declare const instructionsJson: () => JsonSchema;
-export declare const skillsJson: () => JsonSchema;
+export declare const inferenceJson: () => JsonSchema;
+export declare const permissionModeJson: () => JsonSchema;
+export declare const approvalsReviewerJson: () => JsonSchema;
 export declare const secretRefJson: () => JsonSchema;
 export declare const urlJson: (title: string, schemes: readonly string[]) => JsonSchema;
 export declare const absolutePathJson: (title: string) => JsonSchema;
 export declare const modelZod: (ids?: readonly string[]) => z.ZodString;
 export declare const reasoningZod: (levels: readonly ReasoningLevel[]) => z.ZodEnum<typeof ReasoningLevel>;
-export declare const credentialsZod: () => z.ZodObject<{
-    payer: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialPayer>;
-    tryInOrder: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Subscription>;
-        owner: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialOwner>;
-        vendor: z.ZodOptional<z.ZodString>;
-        pin: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.ApiKey>;
-        secret: z.ZodString;
-        baseUrl: z.ZodOptional<z.ZodString>;
-        vendor: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        pin: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.ApiKey>;
-        owner: z.ZodEnum<typeof import("@finalai/agent-provider").CredentialOwner>;
-        vendor: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Platform>;
-        budget: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.HarnessOwned>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<import("@finalai/agent-provider").CredentialNodeKind.Custom>;
-        resolver: z.ZodString;
-        events: z.ZodDefault<z.ZodArray<z.ZodEnum<typeof import("@finalai/agent-provider").DynamicEvent>>>;
-    }, z.core.$strip>]>>;
-}, z.core.$strip>;
-export declare const instructionsZod: () => z.ZodDefault<z.ZodArray<z.ZodObject<{
-    role: z.ZodEnum<typeof import("@finalai/agent-provider").InstructionRole>;
-    content: z.ZodString;
-    source: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>>;
-export declare const skillsZod: () => z.ZodDefault<z.ZodArray<z.ZodObject<{
-    key: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    files: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        content: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>>>;
+export declare const inferenceZod: () => z.ZodPipe<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<import("@finalai/agent-provider").InferenceSourceKind.Subscription>;
+    credential: z.ZodDefault<z.ZodEnum<typeof import("@finalai/agent-provider").CredentialScope>>;
+    vendor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<import("@finalai/agent-provider").InferenceSourceKind.ApiKey>;
+    secret: z.ZodString;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    vendor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<import("@finalai/agent-provider").InferenceSourceKind.Final>;
+    billTo: z.ZodDefault<z.ZodEnum<typeof import("@finalai/agent-provider").InferenceBillTo>>;
+    budget: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<import("@finalai/agent-provider").InferenceSourceKind.Harness>;
+}, z.core.$strict>], "source">, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<import("@finalai/agent-provider").InferenceSourceKind.Subscription>;
+    credential: z.ZodDefault<z.ZodEnum<typeof import("@finalai/agent-provider").CredentialScope>>;
+    vendor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<import("@finalai/agent-provider").InferenceSourceKind.ApiKey>;
+    secret: z.ZodString;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    vendor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<import("@finalai/agent-provider").InferenceSourceKind.Final>;
+    billTo: z.ZodDefault<z.ZodEnum<typeof import("@finalai/agent-provider").InferenceBillTo>>;
+    budget: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<import("@finalai/agent-provider").InferenceSourceKind.Harness>;
+}, z.core.$strict>], "source">>]>, z.ZodTransform<({
+    source: import("@finalai/agent-provider").InferenceSourceKind.Subscription;
+    credential: import("@finalai/agent-provider").CredentialScope;
+    vendor?: string | undefined;
+} | {
+    source: import("@finalai/agent-provider").InferenceSourceKind.ApiKey;
+    secret: string;
+    baseUrl?: string | undefined;
+    vendor?: string | undefined;
+} | {
+    source: import("@finalai/agent-provider").InferenceSourceKind.Final;
+    billTo: import("@finalai/agent-provider").InferenceBillTo;
+    budget?: string | undefined;
+} | {
+    source: import("@finalai/agent-provider").InferenceSourceKind.Harness;
+})[], {
+    source: import("@finalai/agent-provider").InferenceSourceKind.Subscription;
+    credential: import("@finalai/agent-provider").CredentialScope;
+    vendor?: string | undefined;
+} | {
+    source: import("@finalai/agent-provider").InferenceSourceKind.ApiKey;
+    secret: string;
+    baseUrl?: string | undefined;
+    vendor?: string | undefined;
+} | {
+    source: import("@finalai/agent-provider").InferenceSourceKind.Final;
+    billTo: import("@finalai/agent-provider").InferenceBillTo;
+    budget?: string | undefined;
+} | {
+    source: import("@finalai/agent-provider").InferenceSourceKind.Harness;
+} | ({
+    source: import("@finalai/agent-provider").InferenceSourceKind.Subscription;
+    credential: import("@finalai/agent-provider").CredentialScope;
+    vendor?: string | undefined;
+} | {
+    source: import("@finalai/agent-provider").InferenceSourceKind.ApiKey;
+    secret: string;
+    baseUrl?: string | undefined;
+    vendor?: string | undefined;
+} | {
+    source: import("@finalai/agent-provider").InferenceSourceKind.Final;
+    billTo: import("@finalai/agent-provider").InferenceBillTo;
+    budget?: string | undefined;
+} | {
+    source: import("@finalai/agent-provider").InferenceSourceKind.Harness;
+})[]>>;
+export declare const permissionModeZod: () => z.ZodEnum<typeof PermissionLevel>;
+export declare const approvalsReviewerZod: () => z.ZodEnum<typeof ApprovalsReviewer>;
 export declare const secretRefZod: () => z.ZodObject<{
     secretKey: z.ZodString;
 }, z.core.$strip>;
 export declare const urlZod: (schemes: readonly string[]) => z.ZodString;
 export declare const absolutePathZod: () => z.ZodString;
 export declare const parseHarnessConfig: <T extends z.ZodType>(args: {
-    specifier: string;
+    harness: string;
     schema: T;
-    config: JsonValue;
+    config: unknown;
 }) => z.output<T>;
 export declare const toJsonValue: <Value>(value: Value) => JsonValue;
 export declare const toJsonObject: <Value>(value: Value) => JsonObject;
-export type CredentialsInput = CredentialPolicyIface;
-export interface HarnessBindingOutputIface {
-    harness: PackageProviderRefIface;
-    config: object;
-}
-export declare const harnessBinding: <Config extends object>(specifier: string, config: Config) => HarnessBindingOutputIface;
+export declare const harnessSettings: (args: {
+    harness: string;
+    adapter?: string;
+    configuration: {
+        inference?: InferenceInput;
+    } & Record<string, unknown>;
+    environment?: HarnessEnvironmentIface;
+}) => HarnessSettingsIface;

package/dist/modules/harnesses/config-fields.mjs

@@ -1,14 +1,12 @@
-import { MODEL_REFERENCE_PATTERN } from "./model-reference.mjs";
 import {
-  credentialPolicySchema,
-  instructionFragmentSchema,
+  inferenceSchema,
   jsonObjectSchema,
   jsonValueSchema,
-  packageRef,
-  SCHEMA_IDS,
-  skillBundleSchema
+  PermissionLevel,
+  SCHEMA_IDS
 } from "@finalai/agent-provider";
 import * as z from "zod";
+import { MODEL_REFERENCE_PATTERN } from "./model-reference.mjs";
 import { MODEL_REFERENCE_PATTERN as MODEL_REFERENCE_PATTERN2 } from "./model-reference.mjs";
 var ReasoningLevel = /* @__PURE__ */ ((ReasoningLevel2) => {
   ReasoningLevel2["None"] = "none";
@@ -40,17 +38,24 @@ var CodexApprovalPolicy = /* @__PURE__ */ ((CodexApprovalPolicy2) => {
   CodexApprovalPolicy2["Never"] = "never";
   return CodexApprovalPolicy2;
 })(CodexApprovalPolicy || {});
-var CodexApprovalsReviewer = /* @__PURE__ */ ((CodexApprovalsReviewer2) => {
-  CodexApprovalsReviewer2["User"] = "user";
-  CodexApprovalsReviewer2["AutoReview"] = "auto-review";
-  return CodexApprovalsReviewer2;
-})(CodexApprovalsReviewer || {});
+var ApprovalsReviewer = /* @__PURE__ */ ((ApprovalsReviewer2) => {
+  ApprovalsReviewer2["User"] = "user";
+  ApprovalsReviewer2["AutoReview"] = "auto-review";
+  return ApprovalsReviewer2;
+})(ApprovalsReviewer || {});
 var CodexSandboxMode = /* @__PURE__ */ ((CodexSandboxMode2) => {
   CodexSandboxMode2["ReadOnly"] = "read-only";
   CodexSandboxMode2["WorkspaceWrite"] = "workspace-write";
   CodexSandboxMode2["DangerFullAccess"] = "danger-full-access";
   return CodexSandboxMode2;
 })(CodexSandboxMode || {});
+const piPermissionModeFor = (level) => level === PermissionLevel.Auto ? "auto" /* Auto */ : "ask" /* Ask */;
+const claudePermissionModeFor = (level, reviewer = "user" /* User */) => {
+  if (level === PermissionLevel.Auto) return "bypass" /* Bypass */;
+  if (reviewer === "auto-review" /* AutoReview */) return "auto" /* Auto */;
+  return level === PermissionLevel.Review ? "accept-edits" /* AcceptEdits */ : "default" /* Default */;
+};
+const codexApprovalPolicyFor = (level) => level === PermissionLevel.Auto ? "never" /* Never */ : level === PermissionLevel.Review ? "on-request" /* OnRequest */ : "untrusted" /* Untrusted */;
 const configObjectJson = (args) => ({
   type: "object",
   title: args.title,
@@ -68,14 +73,17 @@ const reasoningJson = (levels) => ({
   $ref: SCHEMA_IDS.reasoning,
   enum: [...levels]
 });
-const credentialsJson = () => ({ $ref: SCHEMA_IDS.credentialPolicy });
-const permissionModeJson = (modes, defaultMode) => {
-  const schema = { $ref: SCHEMA_IDS.permissionMode, enum: [...modes] };
-  if (defaultMode != null) schema.default = defaultMode;
-  return schema;
-};
-const instructionsJson = () => ({ $ref: SCHEMA_IDS.instructions });
-const skillsJson = () => ({ $ref: SCHEMA_IDS.skills });
+const inferenceJson = () => ({ $ref: SCHEMA_IDS.inference });
+const permissionModeJson = () => ({
+  $ref: SCHEMA_IDS.permissionMode,
+  enum: Object.values(PermissionLevel)
+});
+const approvalsReviewerJson = () => ({
+  type: "string",
+  title: "Approvals reviewer",
+  enum: Object.values(ApprovalsReviewer),
+  default: "user" /* User */
+});
 const secretRefJson = () => ({ $ref: SCHEMA_IDS.secretRef });
 const urlJson = (title, schemes) => ({
   type: "string",
@@ -101,9 +109,9 @@ const modelZod = (ids) => {
 const reasoningZod = (levels) => z.nativeEnum(ReasoningLevel).refine((level) => levels.includes(level), {
   message: `reasoning must be one of: ${levels.join(", ")}`
 });
-const credentialsZod = () => credentialPolicySchema;
-const instructionsZod = () => z.array(instructionFragmentSchema).default([]);
-const skillsZod = () => z.array(skillBundleSchema).default([]);
+const inferenceZod = () => inferenceSchema;
+const permissionModeZod = () => z.nativeEnum(PermissionLevel);
+const approvalsReviewerZod = () => z.nativeEnum(ApprovalsReviewer);
 const secretRefZod = () => z.object({ secretKey: z.string().min(1) });
 const urlZod = (schemes) => z.string().url().refine((value) => schemes.some((scheme) => value.startsWith(`${scheme}://`)), {
   message: `url must use one of: ${schemes.join(", ")}`
@@ -113,40 +121,55 @@ const parseHarnessConfig = (args) => {
   const parsed = args.schema.safeParse(args.config);
   if (parsed.success) return parsed.data;
   const issues = parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-  throw new Error(`invalid config for ${args.specifier}: ${issues}`);
+  throw new Error(`invalid configuration for ${args.harness}: ${issues}`);
 };
 const toJsonValue = (value) => jsonValueSchema.parse(JSON.parse(JSON.stringify(value)));
 const toJsonObject = (value) => jsonObjectSchema.parse(JSON.parse(JSON.stringify(value)));
-const harnessBinding = (specifier, config) => ({
-  harness: packageRef(specifier),
-  config: { ...config }
-});
+const inferenceList = (inference) => {
+  if (inference == null) return void 0;
+  const list = Array.isArray(inference) ? [...inference] : [inference];
+  if (list.length === 0) throw new Error("inference lists at least one source");
+  return list;
+};
+const harnessSettings = (args) => {
+  const { inference, ...rest } = args.configuration;
+  const list = inferenceList(inference);
+  const environment = args.environment;
+  return {
+    harness: args.harness,
+    ...args.adapter == null ? {} : { adapter: args.adapter },
+    configuration: toJsonObject({ ...rest, ...list == null ? {} : { inference: list } }),
+    ...environment == null ? {} : { environment: typeof environment === "string" ? environment : { ...environment } }
+  };
+};
 export {
+  ApprovalsReviewer,
   ClaudePermissionMode,
   CodexApprovalPolicy,
-  CodexApprovalsReviewer,
   CodexSandboxMode,
   MODEL_REFERENCE_PATTERN2 as MODEL_REFERENCE_PATTERN,
   PiPermissionMode,
   ReasoningLevel,
   absolutePathJson,
   absolutePathZod,
+  approvalsReviewerJson,
+  approvalsReviewerZod,
+  claudePermissionModeFor,
+  codexApprovalPolicyFor,
   configObjectJson,
-  credentialsJson,
-  credentialsZod,
-  harnessBinding,
-  instructionsJson,
-  instructionsZod,
+  harnessSettings,
+  inferenceJson,
+  inferenceZod,
   modelJson,
   modelZod,
   parseHarnessConfig,
   permissionModeJson,
+  permissionModeZod,
+  piPermissionModeFor,
   reasoningJson,
   reasoningZod,
   secretRefJson,
   secretRefZod,
-  skillsJson,
-  skillsZod,
   toJsonObject,
   toJsonValue,
   urlJson,