Function createCodeTool

packages/codemode/src/tool.ts:90–144

(
  options: CreateCodeToolOptions
)

}

export function createCodeTool(
  options: CreateCodeToolOptions
): Tool<CodeInput, CodeOutput> {
  const providers = normalizeProviders(options.tools);

  // Build type block and resolved providers for each provider.
  const typeBlocks: string[] = [];
  const resolvedProviders: ResolvedProvider[] = [];

  for (const provider of providers) {
    const name = provider.name ?? "codemode";
    const filtered = filterTools(provider.tools);
    const types =
      provider.types ?? generateTypes(filtered as ToolDescriptors, name);
    typeBlocks.push(types);
    const resolved: ResolvedProvider = { name, fns: extractFns(filtered) };
    if (provider.positionalArgs) resolved.positionalArgs = true;
    resolvedProviders.push(resolved);
  }

  const typeBlock = typeBlocks.filter(Boolean).join("\n\n");

  const executor = options.executor;

  const description = (options.description ?? DEFAULT_DESCRIPTION).replace(
    "{{types}}",
    typeBlock
  );

  return tool({
    description,
    inputSchema: codeSchema,
    execute: async ({ code }) => {
      const normalizedCode = normalizeCode(code);

      const executeResult = await executor.execute(
        normalizedCode,
        resolvedProviders
      );

      if (executeResult.error) {
        const logCtx = executeResult.logs?.length
          ? `\n\nConsole output:\n${executeResult.logs.join("\n")}`
          : "";
        throw new Error(
          `Code execution failed: ${executeResult.error}${logCtx}`
        );
      }

      const output: CodeOutput = { code, result: executeResult.result };
      if (executeResult.logs) output.logs = executeResult.logs;
      return output;
    }
  });
}