function createModelScopedAgentRegistry(params: {

agentRegistry: AcpAgentRegistry;

scope: AsyncLocalStorage<CodexAcpModelOverride | undefined>;

leaseCommand: (command: string | undefined) => string | undefined;

leaseCommand: (command: string) => string;

}): AcpAgentRegistry {

return {

resolve(agentName: string): string | undefined {

resolve(agentName: string): string {

const command = params.agentRegistry.resolve(agentName);

const override = params.scope.getStore();

if (

!override ||

normalizeAgentName(agentName) !== CODEX_ACP_AGENT_ID ||

typeof command !== "string" ||

!isCodexAcpCommand(command)

) {

return params.leaseCommand(command);

});

}

private commandWithLaunchLease(command: string | undefined): string | undefined {

private commandWithLaunchLease(command: string): string {

const launch = this.launchLeaseScope.getStore();

if (!command || !launch) {

if (!launch) {

return command;

}

launch.stableCommand = command;

});

},

};

export { testing as __testing };

export const XAI_TOOL_SCHEMA_PROFILE = "xai";

export const HTML_ENTITY_TOOL_CALL_ARGUMENTS_ENCODING = "html-entities";

export const XAI_UNSUPPORTED_SCHEMA_KEYWORDS = new Set([

const XAI_UNSUPPORTED_SCHEMA_KEYWORDS = new Set([

"minLength",

"maxLength",

"minItems",

"maxContains",

]);

export function resolveXaiModelCompatPatch(): ModelCompatConfig {

function resolveXaiModelCompatPatch(): ModelCompatConfig {

return {

toolSchemaProfile: XAI_TOOL_SCHEMA_PROFILE,

unsupportedToolSchemaKeywords: Array.from(XAI_UNSUPPORTED_SCHEMA_KEYWORDS),

import { isToolAllowed, resolveSandboxToolPolicyForAgent } from "./sandbox/tool-policy.js";

import type { SandboxToolPolicy } from "./sandbox/types.js";

import { isToolAllowedByPolicyName } from "./tool-policy-match.js";

import { TOOL_POLICY_CONFORMANCE } from "./tool-policy.conformance.js";

import {

collectExplicitAllowlist,

DEFAULT_PLUGIN_TOOLS_ALLOWLIST_ENTRY,

});

});

describe("TOOL_POLICY_CONFORMANCE", () => {

it("matches exported TOOL_GROUPS exactly", () => {

expect(TOOL_POLICY_CONFORMANCE.toolGroups).toEqual(TOOL_GROUPS);

});

it("is JSON-serializable", () => {

const serialized = JSON.stringify(TOOL_POLICY_CONFORMANCE);

expect(JSON.parse(serialized)).toEqual({ toolGroups: TOOL_GROUPS });

});

});

describe("sandbox tool policy", () => {

it("allows all tools with * allow", () => {

const policy: SandboxToolPolicy = { allow: ["*"], deny: [] };