agency-lang 0.0.100 → 0.0.102

package/dist/lib/backends/typescriptBuilder.d.ts

@@ -29,14 +29,18 @@ export declare class TypeScriptBuilder {
     private _sourceMapBuilder;
     private programInfo;
     private moduleId;
+    private outputFile;
     /**
      * @param config - Agency compiler configuration (model defaults, logging, etc.)
      * @param info - Pre-collected program metadata (function definitions, graph nodes, imports, type hints)
      * @param moduleId - Unique identifier for this module (e.g., "foo.agency"), used to
      *   namespace global variables in the GlobalStore so that different modules' globals
      *   don't collide. Must be consistent between the defining module and any importers.
+     * @param outputFile - Absolute path where the generated code will be written.
+     *   Used to compute relative import paths for stdlib. If not provided, falls
+     *   back to resolving moduleId against cwd.
      */
-    constructor(config: AgencyConfig | undefined, info: ProgramInfo, moduleId: string);
+    constructor(config: AgencyConfig | undefined, info: ProgramInfo, moduleId: string, outputFile?: string);
     private configDefaults;
     /** Convert a TsNode to string (for use in template-based methods) */
     private str;

package/dist/lib/backends/typescriptBuilder.js

@@ -76,17 +76,22 @@ export class TypeScriptBuilder {
     _sourceMapBuilder = new SourceMapBuilder();
     programInfo;
     moduleId;
+    outputFile;
     /**
      * @param config - Agency compiler configuration (model defaults, logging, etc.)
      * @param info - Pre-collected program metadata (function definitions, graph nodes, imports, type hints)
      * @param moduleId - Unique identifier for this module (e.g., "foo.agency"), used to
      *   namespace global variables in the GlobalStore so that different modules' globals
      *   don't collide. Must be consistent between the defining module and any importers.
+     * @param outputFile - Absolute path where the generated code will be written.
+     *   Used to compute relative import paths for stdlib. If not provided, falls
+     *   back to resolving moduleId against cwd.
      */
-    constructor(config, info, moduleId) {
+    constructor(config, info, moduleId, outputFile) {
         this.agencyConfig = mergeDeep(this.configDefaults(), config || {});
         this.programInfo = info;
         this.moduleId = moduleId;
+        this.outputFile = outputFile;
     }
     configDefaults() {
         return {
@@ -1042,7 +1047,7 @@ export class TypeScriptBuilder {
         return ts.runnerIfElse({ id, branches, elseBranch });
     }
     processImportStatement(node) {
-        const from = toCompiledImportPath(node.modulePath, path.resolve(this.moduleId));
+        const from = toCompiledImportPath(node.modulePath, this.outputFile ?? path.resolve(this.moduleId));
         const imports = node.importedNames.map((nameType) => {
             switch (nameType.type) {
                 case "namedImport":
@@ -1093,7 +1098,7 @@ export class TypeScriptBuilder {
         return ts.importDecl({
             importKind: "named",
             names: importNames,
-            from: toCompiledImportPath(node.agencyFile, path.resolve(this.moduleId)),
+            from: toCompiledImportPath(node.agencyFile, this.outputFile ?? path.resolve(this.moduleId)),
         });
     }
     // ------- TsRaw wrapper methods (template-heavy) -------
@@ -1636,6 +1641,12 @@ export class TypeScriptBuilder {
             })),
         ]), ts.statements([
             ts.if(ts.raw("__error instanceof RestoreSignal"), ts.statements([ts.throw("__error")])),
+            ts.consoleError(ts.template([
+                {
+                    text: "\\nAgent crashed: ",
+                    expr: $(ts.id("__error")).prop("message").done(),
+                },
+            ])),
             ts.return(ts.obj({
                 messages: ts.runtime.threads,
                 data: ts.raw(`failure(__error instanceof Error ? __error.message : String(__error), { functionName: ${JSON.stringify(nodeName)} })`),
@@ -1863,6 +1874,7 @@ export class TypeScriptBuilder {
         const configArg = node.arguments[1];
         let clientConfig;
         let configToolNames = [];
+        let configToolExprs = [];
         if (configArg && configArg.type === "agencyObject") {
             // Extract tools from config object
             const toolsEntry = configArg.entries.find((e) => !("type" in e && e.type === "splat") &&
@@ -1882,6 +1894,10 @@ export class TypeScriptBuilder {
                             configToolNames.push(toolArg.value);
                         }
                     }
+                    else if (item.type === "splat") {
+                        // Pass-through: spread MCP tool arrays (or any other spread) directly
+                        configToolExprs.push(ts.spread(this.processNode(item.value)));
+                    }
                 }
             }
             // Build clientConfig without known keys
@@ -1913,12 +1929,14 @@ export class TypeScriptBuilder {
         const toolNodes = allToolNames.map((name) => $(ts.id("tool"))
             .call([ts.str(name)])
             .done());
+        // Merge registry-resolved tools with pass-through expressions (spreads of MCP tools, etc.)
+        const allToolNodes = [...toolNodes, ...configToolExprs];
         // Merge tools into clientConfig
         let mergedConfig;
-        if (allToolNames.length > 0) {
+        if (allToolNodes.length > 0) {
             // Spread user config and add tools
             mergedConfig = ts.obj([
-                ts.set("tools", ts.arr(toolNodes)),
+                ts.set("tools", ts.arr(allToolNodes)),
                 ts.setSpread(clientConfig),
             ]);
         }
@@ -2419,10 +2437,23 @@ export class TypeScriptBuilder {
             traceConfigFields.traceFile = ts.str(this.agencyConfig.traceFile);
         }
         runtimeCtxArgs.traceConfig = ts.obj(traceConfigFields);
-        let runtimeCtx = ts.statements([
+        const runtimeCtxStatements = [
             ts.constDecl("__globalCtx", ts.new(ts.id("RuntimeContext"), [ts.obj(runtimeCtxArgs)])),
             ts.constDecl("graph", $(ts.runtime.globalCtx).prop("graph").done()),
-        ]);
+        ];
+        if (this.agencyConfig.mcpServers) {
+            // Strip secrets from the config before embedding in generated code.
+            // clientId and clientSecret are resolved at runtime from env vars.
+            const sanitizedServers = Object.fromEntries(Object.entries(this.agencyConfig.mcpServers).map(([name, cfg]) => {
+                if ("type" in cfg && cfg.type === "http") {
+                    const { clientSecret, clientId, ...rest } = cfg;
+                    return [name, rest];
+                }
+                return [name, cfg];
+            }));
+            runtimeCtxStatements.push(ts.raw(`__globalCtx.createMcpManager(${JSON.stringify(sanitizedServers)});`));
+        }
+        let runtimeCtx = ts.statements(runtimeCtxStatements);
         return renderImports.default({
             runtimeContextCode: printTs(runtimeCtx),
         });

package/dist/lib/backends/typescriptGenerator/builtins.js

@@ -1,6 +1,7 @@
 import * as builtinFunctionsInput from "../../templates/backends/typescriptGenerator/builtinFunctions/input.js";
 import * as builtinFunctionsRead from "../../templates/backends/typescriptGenerator/builtinFunctions/read.js";
 import * as builtinFunctionsFetchJSON from "../../templates/backends/typescriptGenerator/builtinFunctions/fetchJSON.js";
+import * as builtinFunctionsMcp from "../../templates/backends/typescriptGenerator/builtinFunctions/mcp.js";
 import { BUILTIN_FUNCTIONS } from "../../config.js";
 /**
  * Maps an Agency function name to its TypeScript equivalent
@@ -46,5 +47,7 @@ export function generateBuiltinHelpers(functionsUsed) {
         helpers.push(sleepFunc);
       }
      */
+    const mcpFunc = builtinFunctionsMcp.default({});
+    helpers.push(mcpFunc);
     return helpers.join("\n\n");
 }

package/dist/lib/backends/typescriptGenerator.d.ts

@@ -1,4 +1,4 @@
 import { AgencyProgram } from "../types.js";
 import { type ProgramInfo } from "../programInfo.js";
 import { AgencyConfig } from "../config.js";
-export declare function generateTypeScript(program: AgencyProgram, config?: AgencyConfig, info?: ProgramInfo, moduleId?: string): string;
+export declare function generateTypeScript(program: AgencyProgram, config?: AgencyConfig, info?: ProgramInfo, moduleId?: string, outputFile?: string): string;

package/dist/lib/backends/typescriptGenerator.js

@@ -2,14 +2,14 @@ import { TypescriptPreprocessor } from "../preprocessors/typescriptPreprocessor.
 import { collectProgramInfo } from "../programInfo.js";
 import { TypeScriptBuilder } from "./typescriptBuilder.js";
 import { printTs } from "../ir/prettyPrint.js";
-export function generateTypeScript(program, config, info, moduleId) {
+export function generateTypeScript(program, config, info, moduleId, outputFile) {
     if (!moduleId) {
         throw new Error("moduleId is required for generateTypeScript");
     }
     const programInfo = info ?? collectProgramInfo(program);
     const preprocessor = new TypescriptPreprocessor(program, config, programInfo);
     const preprocessedProgram = preprocessor.preprocess();
-    const builder = new TypeScriptBuilder(config, programInfo, moduleId);
+    const builder = new TypeScriptBuilder(config, programInfo, moduleId, outputFile);
     const ir = builder.build(preprocessedProgram);
     return printTs(ir);
 }

package/dist/lib/cli/auth.d.ts

@@ -0,0 +1,4 @@
+import type { AgencyConfig } from "../config.js";
+export declare function authServer(serverName: string, config: AgencyConfig): Promise<void>;
+export declare function listAuth(): Promise<void>;
+export declare function revokeAuth(serverName: string): Promise<void>;

package/dist/lib/cli/auth.js

@@ -0,0 +1,60 @@
+import { TokenStore } from "../runtime/mcp/tokenStore.js";
+import { OAuthConnector } from "../runtime/mcp/oauthConnector.js";
+import { isOAuthServer } from "../runtime/mcp/types.js";
+const store = new TokenStore();
+export async function authServer(serverName, config) {
+    const mcpServers = config.mcpServers;
+    if (!mcpServers || !mcpServers[serverName]) {
+        console.error(`MCP server "${serverName}" not found in agency.json. Available servers: ${mcpServers ? Object.keys(mcpServers).join(", ") : "(none)"}`);
+        process.exit(1);
+    }
+    const serverConfig = mcpServers[serverName];
+    if (!isOAuthServer(serverConfig)) {
+        console.error(`MCP server "${serverName}" is not configured with auth: "oauth".`);
+        process.exit(1);
+    }
+    const httpConfig = serverConfig;
+    const existing = await store.loadTokens(serverName);
+    if (existing) {
+        console.log(`Token already exists for "${serverName}". Use --revoke to remove it first.`);
+        return;
+    }
+    console.log(`Starting OAuth authorization for "${serverName}"...`);
+    const connector = new OAuthConnector(serverName, httpConfig.url, store, {
+        timeoutMs: httpConfig.authTimeout,
+        clientId: httpConfig.clientId,
+        clientSecret: httpConfig.clientSecret,
+    });
+    try {
+        const { client } = await connector.connect();
+        console.log(`Successfully authorized "${serverName}". Token stored.`);
+        await client.close();
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Authorization failed for "${serverName}": ${msg}`);
+        process.exit(1);
+    }
+}
+export async function listAuth() {
+    const servers = await store.listServers();
+    if (servers.length === 0) {
+        console.log("No stored OAuth tokens.");
+        return;
+    }
+    console.log("Stored OAuth tokens:");
+    for (const name of servers) {
+        const tokens = await store.loadTokens(name);
+        const hasRefresh = tokens?.refresh_token ? "yes" : "no";
+        console.log(`  ${name} (refresh token: ${hasRefresh})`);
+    }
+}
+export async function revokeAuth(serverName) {
+    const tokens = await store.loadTokens(serverName);
+    if (!tokens) {
+        console.log(`No stored token for "${serverName}".`);
+        return;
+    }
+    await store.deleteTokens(serverName);
+    console.log(`Removed stored token for "${serverName}".`);
+}

package/dist/lib/cli/commands.js

@@ -1,4 +1,5 @@
 import { generateAgency } from "../backends/agencyGenerator.js";
+import { AgencyConfigSchema } from "../config.js";
 import { generateTypeScript } from "../index.js";
 import { resolveImports } from "../preprocessors/importResolver.js";
 import { collectProgramInfo } from "../programInfo.js";
@@ -26,6 +27,15 @@ export function loadConfig(configPath, verbose = false) {
         try {
             const configContent = fs.readFileSync(finalConfigPath, "utf-8");
             config = JSON.parse(configContent);
+            const parseResult = AgencyConfigSchema.safeParse(config);
+            if (!parseResult.success) {
+                console.error(`Invalid agency.json config:`);
+                for (const issue of parseResult.error.issues) {
+                    console.error(`  - ${issue.path.join(".")}: ${issue.message}`);
+                }
+                process.exit(1);
+            }
+            config = parseResult.data;
             if (config.verbose) {
                 console.log(`Loaded config from ${finalConfigPath}`);
             }
@@ -79,6 +89,10 @@ export function resetCompilationCache() {
     compiledFiles.clear();
 }
 export function compile(config, inputFile, _outputFile, options) {
+    if (!fs.existsSync(inputFile)) {
+        console.error(`Error: Input file '${inputFile}' not found`);
+        process.exit(1);
+    }
     // Check if the input is a directory
     const stats = fs.statSync(inputFile);
     const verbose = config.verbose ?? false;
@@ -154,9 +168,16 @@ export function compile(config, inputFile, _outputFile, options) {
             nonAgencyImports.push(node.modulePath);
         }
     });
-    strategy.prepareDependencies(nonAgencyImports, absoluteInputFile);
+    try {
+        strategy.prepareDependencies(nonAgencyImports, absoluteInputFile);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
     const moduleId = path.relative(process.cwd(), absoluteInputFile);
-    const generatedCode = generateTypeScript(resolvedProgram, config, info, moduleId);
+    const absoluteOutputFile = path.resolve(outputFile);
+    const generatedCode = generateTypeScript(resolvedProgram, config, info, moduleId, absoluteOutputFile);
     if (options?.ts) {
         // TypeScript output — add @ts-nocheck so type errors don't block compilation
         fs.writeFileSync(outputFile, "// @ts-nocheck\n" + generatedCode, "utf-8");

package/dist/lib/cli/debug.js

@@ -83,7 +83,14 @@ export async function debug(config, _inputFile, options = {}) {
         let absOutput;
         if (distDir) {
             // distDir mode: import pre-compiled JS from the dist directory
-            const compiledPath = resolveCompiledFile(distDir, inputFile);
+            let compiledPath;
+            try {
+                compiledPath = resolveCompiledFile(distDir, inputFile);
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
             // Warn if source is newer than compiled output
             const sourceMtime = fs.statSync(inputFile).mtimeMs;
             const compiledMtime = fs.statSync(compiledPath).mtimeMs;

package/dist/lib/config.d.ts

@@ -1,4 +1,6 @@
 import { AgencyNode } from "./types.js";
+import { z } from "zod";
+import type { McpServerConfig } from "./runtime/mcp/types.js";
 export declare const TYPES_THAT_DONT_TRIGGER_NEW_PART: AgencyNode["type"][];
 /**
  * Maps Agency built-in function names to TypeScript equivalents.
@@ -117,4 +119,71 @@ export interface AgencyConfig {
         /** Base URL for source links in generated docs */
         baseUrl?: string;
     };
+    /** MCP server configurations */
+    mcpServers?: Record<string, McpServerConfig>;
 }
+export declare const AgencyConfigSchema: z.ZodObject<{
+    verbose: z.ZodOptional<z.ZodBoolean>;
+    outDir: z.ZodOptional<z.ZodString>;
+    excludeNodeTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludeBuiltinFunctions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allowedFetchDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disallowedFetchDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tarsecTraceHost: z.ZodOptional<z.ZodString>;
+    maxToolCallRounds: z.ZodOptional<z.ZodNumber>;
+    log: z.ZodOptional<z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        debugMode: z.ZodOptional<z.ZodBoolean>;
+        apiKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    client: z.ZodOptional<z.ZodObject<{
+        logLevel: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            warn: "warn";
+            info: "info";
+            debug: "debug";
+        }>>;
+        defaultModel: z.ZodOptional<z.ZodString>;
+        openAiApiKey: z.ZodOptional<z.ZodString>;
+        googleApiKey: z.ZodOptional<z.ZodString>;
+        statelog: z.ZodOptional<z.ZodObject<{
+            host: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+            apiKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    strictTypes: z.ZodOptional<z.ZodBoolean>;
+    typeCheck: z.ZodOptional<z.ZodBoolean>;
+    typeCheckStrict: z.ZodOptional<z.ZodBoolean>;
+    restrictImports: z.ZodOptional<z.ZodBoolean>;
+    debugger: z.ZodOptional<z.ZodBoolean>;
+    instrument: z.ZodOptional<z.ZodBoolean>;
+    checkpoints: z.ZodOptional<z.ZodObject<{
+        maxRestores: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    trace: z.ZodOptional<z.ZodBoolean>;
+    traceFile: z.ZodOptional<z.ZodString>;
+    traceDir: z.ZodOptional<z.ZodString>;
+    distDir: z.ZodOptional<z.ZodString>;
+    test: z.ZodOptional<z.ZodObject<{
+        parallel: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    doc: z.ZodOptional<z.ZodObject<{
+        outDir: z.ZodOptional<z.ZodString>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"http">;
+        url: z.ZodString;
+        auth: z.ZodOptional<z.ZodLiteral<"oauth">>;
+        authTimeout: z.ZodOptional<z.ZodNumber>;
+        clientId: z.ZodOptional<z.ZodString>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>]>>>;
+}, z.core.$loose>;

package/dist/lib/config.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 export const TYPES_THAT_DONT_TRIGGER_NEW_PART = [
     "typeAlias",
     "usesTool",
@@ -16,3 +17,107 @@ export const BUILTIN_TOOLS = [
     "readSkill",
 ];
 export const BUILTIN_VARIABLES = ["color"];
+// --- Zod schema for runtime validation of agency.json ---
+const McpStdioServerSchema = z.object({
+    command: z.string(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+}).strict();
+const McpHttpServerSchema = z.object({
+    type: z.literal("http"),
+    url: z.string(),
+    auth: z.literal("oauth").optional(),
+    authTimeout: z.number().optional(),
+    clientId: z.string().optional(),
+    clientSecret: z.string().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+}).strict();
+const McpServerSchema = z.union([McpStdioServerSchema, McpHttpServerSchema]);
+export const AgencyConfigSchema = z.object({
+    verbose: z.boolean(),
+    outDir: z.string(),
+    excludeNodeTypes: z.array(z.string()),
+    excludeBuiltinFunctions: z.array(z.string()),
+    allowedFetchDomains: z.array(z.string()),
+    disallowedFetchDomains: z.array(z.string()),
+    tarsecTraceHost: z.string(),
+    maxToolCallRounds: z.number(),
+    log: z.object({ host: z.string(), projectId: z.string(), debugMode: z.boolean(), apiKey: z.string() }).partial(),
+    client: z.object({
+        logLevel: z.enum(["error", "warn", "info", "debug"]),
+        defaultModel: z.string(),
+        openAiApiKey: z.string(),
+        googleApiKey: z.string(),
+        statelog: z.object({ host: z.string(), projectId: z.string(), apiKey: z.string() }).partial(),
+    }).partial(),
+    strictTypes: z.boolean(),
+    typeCheck: z.boolean(),
+    typeCheckStrict: z.boolean(),
+    restrictImports: z.boolean(),
+    debugger: z.boolean(),
+    instrument: z.boolean(),
+    checkpoints: z.object({ maxRestores: z.number() }).partial(),
+    trace: z.boolean(),
+    traceFile: z.string(),
+    traceDir: z.string(),
+    distDir: z.string(),
+    test: z.object({ parallel: z.number() }).partial(),
+    doc: z.object({ outDir: z.string(), baseUrl: z.string() }).partial(),
+    mcpServers: z.record(z.string().regex(/^[A-Za-z0-9_-]+$/, "MCP server names must contain only letters, numbers, hyphens, and underscores"), McpServerSchema),
+}).partial().passthrough().superRefine((data, ctx) => {
+    if (!data.mcpServers)
+        return;
+    for (const [name, server] of Object.entries(data.mcpServers)) {
+        if ("type" in server && server.type === "http") {
+            const httpServer = server;
+            if (httpServer.auth && httpServer.headers) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `MCP server "${name}": cannot specify both 'auth' and 'headers'`,
+                    path: ["mcpServers", name],
+                });
+            }
+            if (httpServer.authTimeout && httpServer.auth !== "oauth") {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `MCP server "${name}": 'authTimeout' requires 'auth: "oauth"'`,
+                    path: ["mcpServers", name],
+                });
+            }
+            if (httpServer.clientId && httpServer.auth !== "oauth") {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `MCP server "${name}": 'clientId' requires 'auth: "oauth"'`,
+                    path: ["mcpServers", name],
+                });
+            }
+            if (httpServer.clientSecret && httpServer.auth !== "oauth") {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `MCP server "${name}": 'clientSecret' requires 'auth: "oauth"'`,
+                    path: ["mcpServers", name],
+                });
+            }
+            if (httpServer.auth === "oauth") {
+                try {
+                    const parsed = new URL(httpServer.url);
+                    const isLocalhost = ["127.0.0.1", "localhost"].includes(parsed.hostname);
+                    if (parsed.protocol !== "https:" && !isLocalhost) {
+                        ctx.addIssue({
+                            code: z.ZodIssueCode.custom,
+                            message: `MCP server "${name}": OAuth requires HTTPS (or localhost for development)`,
+                            path: ["mcpServers", name, "url"],
+                        });
+                    }
+                }
+                catch {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        message: `MCP server "${name}": invalid URL "${httpServer.url}"`,
+                        path: ["mcpServers", name, "url"],
+                    });
+                }
+            }
+        }
+    }
+});

package/dist/lib/config.test.d.ts

@@ -0,0 +1 @@
+export {};