Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 11 additions & 1 deletion src/tools/BashProgrammaticToolCalling.ts
Original file line number Diff line number Diff line change
Expand Up @@ -149,13 +149,16 @@ ${STATELESS_WARNING}

Each tool function accepts a JSON string as its argument.
Example: tool_name '{"key": "value"}'
${ADDITIONAL_RULES}

${EXAMPLES}

${CORE_RULES}`;

const TOOL_MANIFEST_DESCRIPTION =
'Exact registered tool names used by the code. Required when direct-only tools are configured; ' +
'Registered tool names used by the code. For hyphenated names, you can also use the unambiguous ' +
'underscore function name from the script (e.g., echo_mcp_my_server for echo_mcp_my-server). ' +
'Required when direct-only tools are configured; ' +
'validated before execution starts. Pass [] when the code calls no tools at all.';

// ============================================================================
Expand Down Expand Up @@ -433,6 +436,13 @@ export function createBashProgrammaticToolCallingTool(
allowedToolDefs: toolDefs,
disallowedToolDefs,
programmaticToolName,
getManifestAlias: (name) => {
if (!name.includes('-')) {
return undefined;
}
const identifier = normalizeToBashIdentifier(name);
return /^_ptc_/i.test(identifier) ? `${identifier}_tool` : identifier;
},
});

/* These guard the replay path only. A call that selected no tools never
Expand Down
34 changes: 30 additions & 4 deletions src/tools/ProgrammaticCallerPolicy.ts
Original file line number Diff line number Diff line change
Expand Up @@ -79,10 +79,11 @@ export function selectProgrammaticTools(args: {
allowedToolDefs?: t.LCTool[];
disallowedToolDefs?: t.LCTool[];
programmaticToolName: string;
getManifestAlias?: (name: string) => string | undefined;
}): t.LCTool[] {
const allowedToolDefs = args.allowedToolDefs ?? [];
const disallowedToolDefs = args.disallowedToolDefs ?? [];
const requestedToolNames = args.requestedToolNames;
let requestedToolNames = args.requestedToolNames;

if (requestedToolNames == null) {
if (disallowedToolDefs.length > 0) {
Expand All @@ -97,6 +98,34 @@ export function selectProgrammaticTools(args: {
const disallowedNames = new Set(
disallowedToolDefs.map((toolDef) => toolDef.name)
);
const allowedByName = new Map(
allowedToolDefs.map((toolDef) => [toolDef.name, toolDef])
);
const getManifestAlias = args.getManifestAlias;
if (getManifestAlias != null) {
const aliases = new Map<string, string | null>();
for (const name of [...allowedByName.keys(), ...disallowedNames]) {
const alias = getManifestAlias(name);
if (alias == null || alias === name) {
continue;
}
const prior = aliases.get(alias);
aliases.set(alias, prior === undefined || prior === name ? name : null);
}
requestedToolNames = requestedToolNames.map((name) => {
if (allowedByName.has(name) || disallowedNames.has(name)) {
return name;
}
const registeredName = aliases.get(name);
if (registeredName === null) {
throw new Error(
`Tool identifier "${name}" is ambiguous in "${args.programmaticToolName}". ` +
'Use an exact registered tool name in the tool_manifest field.'
);
}
return registeredName ?? name;
});
}
const requestedDisallowedNames = new Set(
requestedToolNames.filter((name) => disallowedNames.has(name))
);
Expand All @@ -105,9 +134,6 @@ export function selectProgrammaticTools(args: {
args.programmaticToolName
);

const allowedByName = new Map(
allowedToolDefs.map((toolDef) => [toolDef.name, toolDef])
);
const unknownNames = new Set(
requestedToolNames.filter((name) => !allowedByName.has(name))
);
Expand Down
72 changes: 72 additions & 0 deletions src/tools/__tests__/ProgrammaticPlainExecution.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -150,6 +150,78 @@ const invokePython = (
context
);

describe('Bash tool manifest aliases', () => {
const registered = 'echo_mcp_my-server';
const identifier = 'echo_mcp_my_server';
const code = `result=$(${identifier} '{}'); echo "$result"`;
const tools = new Map([[registered, createGetWeatherTool()]]);

beforeEach(() => {
requests.length = 0;
});

it.each([
{ tool_manifest: [identifier] },
{ tool_manifest: [registered] },
{ tool_manifest: [identifier, registered] },
])(
'sends the registered tool when selecting with %j',
async ({ tool_manifest }) => {
await invokeBash(
{ code, tool_manifest },
{
toolMap: tools,
toolDefs: [{ name: registered }],
disallowedToolDefs: [{ name: 'direct_only' }],
}
);

expect(requests).toHaveLength(1);
expect(requests[0].url).toBe(`${BASE_URL}/exec/programmatic`);
expect(requests[0].body.tools).toEqual([{ name: registered }]);
expect(requests[0].body.code).toContain(code);
}
);

it('rejects aliases for direct-only tools', async () => {
await expect(
invokeBash(
{ code, tool_manifest: [identifier] },
{ toolDefs: [], disallowedToolDefs: [{ name: registered }] }
)
).rejects.toThrow('not marked for code_execution');
expect(requests).toHaveLength(0);
});

it('rejects ambiguous aliases across the two caller policies', async () => {
await expect(
invokeBash(
{ code, tool_manifest: [identifier] },
{
toolMap: tools,
toolDefs: [{ name: registered }],
disallowedToolDefs: [{ name: 'echo_mcp-my_server' }],
}
)
).rejects.toThrow('is ambiguous');
expect(requests).toHaveLength(0);
});

it('preserves exact direct-only names that match an allowed alias', async () => {
await expect(
invokeBash(
{ code, tool_manifest: [identifier] },
{
toolMap: tools,
toolDefs: [{ name: registered }],
disallowedToolDefs: [{ name: identifier }],
}
)
).rejects.toThrow('not marked for code_execution');
expect(requests).toHaveLength(0);
});
});

describe('an empty tool manifest runs instead of being rejected', () => {
beforeEach(() => {
requests.length = 0;
Expand Down