@holoscript/core 8.0.8 → 8.0.10

package/dist/chunk-BCP4E7MD.cjs

@@ -0,0 +1,997 @@
+'use strict';
+
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/AgentInferenceExportTarget.ts
+var AgentInferenceExportTarget_exports = {};
+chunkZHPMP447_cjs.__export(AgentInferenceExportTarget_exports, {
+  AgentInferenceCompiler: () => exports.AgentInferenceCompiler,
+  createAgentInferenceCompiler: () => createAgentInferenceCompiler,
+  createPythonAgentInferenceCompiler: () => createPythonAgentInferenceCompiler,
+  default: () => exports.AgentInferenceExportTarget_default
+});
+function modelAcceptsSamplingParams(modelName) {
+  return !ANTHROPIC_MODELS_NO_SAMPLING_PARAMS.has(modelName);
+}
+function createAgentInferenceCompiler(options) {
+  return new exports.AgentInferenceCompiler(options);
+}
+function createPythonAgentInferenceCompiler(options) {
+  return new exports.AgentInferenceCompiler({ ...options, language: "python" });
+}
+var DEFAULT_MODEL_CONFIG, ANTHROPIC_MODELS_NO_SAMPLING_PARAMS, AGENT_TRAIT_NAMES; exports.AgentInferenceCompiler = void 0; exports.AgentInferenceExportTarget_default = void 0;
+var init_AgentInferenceExportTarget = chunkZHPMP447_cjs.__esm({
+  "src/compiler/AgentInferenceExportTarget.ts"() {
+    chunkZK7KX5CD_cjs.init_CompilerBase();
+    DEFAULT_MODEL_CONFIG = {
+      provider: "anthropic",
+      // Default to Opus 4.7 — most capable Claude. Users override per-agent via
+      // the `@model` trait. NEVER silently downgrade for cost (per API skill rule).
+      name: "claude-opus-4-7",
+      temperature: 0.7,
+      maxTokens: 16e3,
+      // bumped from 4096 — current API default guidance
+      topP: 0.9,
+      topK: 40,
+      systemPrompt: "You are a helpful AI agent."
+    };
+    ANTHROPIC_MODELS_NO_SAMPLING_PARAMS = /* @__PURE__ */ new Set(["claude-opus-4-7"]);
+    AGENT_TRAIT_NAMES = /* @__PURE__ */ new Set([
+      "agent",
+      "model",
+      "inference",
+      "system_prompt",
+      "prompt",
+      "temperature",
+      "max_tokens",
+      "top_p",
+      "top_k",
+      "tool",
+      "tool_use",
+      "reasoning",
+      "memory",
+      "persona"
+    ]);
+    exports.AgentInferenceCompiler = class extends chunkZK7KX5CD_cjs.CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "AgentInferenceCompiler";
+        this.agents = [];
+        this.warnings = [];
+        this.options = {
+          language: options.language ?? "typescript",
+          defaultProvider: options.defaultProvider ?? "anthropic",
+          defaultModel: options.defaultModel ?? "claude-sonnet-4-6",
+          defaultTemperature: options.defaultTemperature ?? 0.7,
+          defaultMaxTokens: options.defaultMaxTokens ?? 4096,
+          includeTypes: options.includeTypes ?? true,
+          includeReadme: options.includeReadme ?? true,
+          includeEnvTemplate: options.includeEnvTemplate ?? true
+        };
+      }
+      getRequiredCapability() {
+        return ans.ANSCapabilityPath.AGENT_INFERENCE;
+      }
+      /**
+       * Compile a HoloScript composition to runnable agent inference scripts.
+       *
+       * Extracts agent definitions from objects with @agent/@model/@tool traits,
+       * NPCs, dialogue trees, state machines, and domain blocks, then generates
+       * a complete multi-file agent project.
+       */
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        this.agents = [];
+        this.warnings = [];
+        this.extractAgentsFromObjects(composition);
+        this.extractAgentsFromNPCs(composition);
+        this.extractAgentsFromDomainBlocks(composition);
+        if (this.agents.length === 0) {
+          this.agents.push(this.createDefaultAgent(composition));
+          this.warnings.push(
+            "No @agent traits found in composition. Created default agent from composition name."
+          );
+        }
+        const output = {};
+        const ext = this.options.language === "typescript" ? "ts" : "py";
+        output[`agent.${ext}`] = this.emitAgentScript(composition.name);
+        const allTools = this.agents.flatMap((a) => a.tools);
+        if (allTools.length > 0) {
+          output[`tools.${ext}`] = this.emitToolDefinitions(allTools);
+        }
+        output["config.json"] = this.emitConfigJson();
+        if (this.options.language === "typescript") {
+          output["package.json"] = this.emitPackageJson(composition.name);
+          if (this.options.includeTypes) {
+            output["types.ts"] = this.emitTypeDefinitions();
+          }
+        } else {
+          output["requirements.txt"] = this.emitRequirementsTxt();
+        }
+        if (this.options.includeEnvTemplate) {
+          output[".env.example"] = this.emitEnvTemplate();
+        }
+        if (this.options.includeReadme) {
+          output["README.md"] = this.emitReadme(composition.name);
+        }
+        return output;
+      }
+      /** Get extracted agents (for inspection/testing). */
+      getAgents() {
+        return this.agents;
+      }
+      /** Get warnings from last compilation. */
+      getWarnings() {
+        return this.warnings;
+      }
+      // ─── AST Extraction ─────────────────────────────────────────────────
+      extractAgentsFromObjects(composition) {
+        for (const obj of composition.objects) {
+          if (this.hasAgentTraits(obj)) {
+            this.agents.push(this.parseAgentObject(obj));
+          }
+          if (obj.children) {
+            for (const child of obj.children) {
+              if (this.hasAgentTraits(child)) {
+                this.agents.push(this.parseAgentObject(child));
+              }
+            }
+          }
+        }
+      }
+      extractAgentsFromNPCs(composition) {
+        for (const npc of composition.npcs) {
+          this.agents.push(this.parseNPCAsAgent(npc, composition));
+        }
+      }
+      extractAgentsFromDomainBlocks(composition) {
+        if (!composition.domainBlocks) return;
+        for (const block of composition.domainBlocks) {
+          if (this.isAgentDomainBlock(block)) {
+            this.agents.push(this.parseDomainBlockAsAgent(block));
+          }
+        }
+      }
+      hasAgentTraits(obj) {
+        return obj.traits.some((t) => AGENT_TRAIT_NAMES.has(t.name));
+      }
+      parseAgentObject(obj) {
+        const modelConfig = { ...DEFAULT_MODEL_CONFIG };
+        modelConfig.provider = this.options.defaultProvider;
+        modelConfig.name = this.options.defaultModel;
+        modelConfig.temperature = this.options.defaultTemperature;
+        modelConfig.maxTokens = this.options.defaultMaxTokens;
+        const tools = [];
+        const behaviors = [];
+        const stateProperties = [];
+        let role = "assistant";
+        for (const trait of obj.traits) {
+          switch (trait.name) {
+            case "agent":
+              role = this.extractStringValue(trait.config["role"]) ?? role;
+              break;
+            case "model":
+              this.applyModelConfig(trait, modelConfig);
+              break;
+            case "inference":
+              this.applyModelConfig(trait, modelConfig);
+              break;
+            case "system_prompt":
+            case "prompt":
+              modelConfig.systemPrompt = this.extractStringValue(trait.config["text"]) ?? this.extractStringValue(trait.config["content"]) ?? modelConfig.systemPrompt;
+              break;
+            case "temperature":
+              modelConfig.temperature = this.extractNumberValue(trait.config["value"]) ?? modelConfig.temperature;
+              break;
+            case "max_tokens":
+              modelConfig.maxTokens = this.extractNumberValue(trait.config["value"]) ?? modelConfig.maxTokens;
+              break;
+            case "top_p":
+              modelConfig.topP = this.extractNumberValue(trait.config["value"]) ?? modelConfig.topP;
+              break;
+            case "top_k":
+              modelConfig.topK = this.extractNumberValue(trait.config["value"]) ?? modelConfig.topK;
+              break;
+            case "tool":
+            case "tool_use":
+              tools.push(this.parseToolTrait(trait));
+              break;
+            case "persona":
+              modelConfig.systemPrompt = this.extractStringValue(trait.config["description"]) ?? modelConfig.systemPrompt;
+              break;
+          }
+        }
+        if (obj.state) {
+          for (const prop of obj.state.properties) {
+            stateProperties.push({
+              key: prop.key,
+              type: typeof prop.value === "number" ? "number" : typeof prop.value === "boolean" ? "boolean" : "string",
+              defaultValue: String(prop.value ?? "")
+            });
+          }
+        }
+        return {
+          name: obj.name,
+          role,
+          modelConfig,
+          tools,
+          behaviors,
+          stateProperties,
+          dialogueHandlers: []
+        };
+      }
+      parseNPCAsAgent(npc, composition) {
+        const modelConfig = { ...DEFAULT_MODEL_CONFIG };
+        modelConfig.provider = this.options.defaultProvider;
+        modelConfig.name = this.options.defaultModel;
+        modelConfig.temperature = this.options.defaultTemperature;
+        modelConfig.maxTokens = this.options.defaultMaxTokens;
+        const npcType = npc.npcType ?? "assistant";
+        const npcProps = npc.properties.map((p) => `${p.key}: ${String(p.value)}`).join(", ");
+        modelConfig.systemPrompt = `You are a ${npcType} named ${npc.name}. ${npcProps}`;
+        const tools = npc.behaviors.map((b) => this.parseBehaviorAsTool(b));
+        const behaviors = npc.behaviors.map((b) => ({
+          name: b.name,
+          trigger: b.trigger,
+          actions: b.actions.map((a) => a.actionType),
+          priority: b.priority ?? 0
+        }));
+        const dialogueHandlers = [];
+        if (npc.dialogueTree) {
+          const dialogue = composition.dialogues.find(
+            // @ts-expect-error During migration
+            (d) => d.name === npc.dialogueTree
+          );
+          if (dialogue) {
+            dialogueHandlers.push({
+              // @ts-expect-error During migration
+              id: dialogue.name,
+              // @ts-expect-error During migration
+              prompt: `Dialogue tree: ${dialogue.name}`,
+              // @ts-expect-error During migration
+              responses: dialogue.nodes?.map((n) => n.text ?? n.name ?? "") ?? []
+            });
+          }
+        }
+        return {
+          name: npc.name,
+          role: npcType,
+          modelConfig,
+          tools,
+          behaviors,
+          stateProperties: [],
+          dialogueHandlers
+        };
+      }
+      parseDomainBlockAsAgent(block) {
+        const modelConfig = { ...DEFAULT_MODEL_CONFIG };
+        modelConfig.provider = this.options.defaultProvider;
+        modelConfig.name = this.options.defaultModel;
+        const name = block.name ?? block.blockType ?? "DomainAgent";
+        const tools = [];
+        if (block.objects) {
+          for (const obj of block.objects) {
+            tools.push({
+              name: this.toSnakeCase(obj.name),
+              description: `Domain operation: ${obj.name}`,
+              // @ts-expect-error During migration
+              parameters: obj.properties.map((p) => ({
+                name: p.key,
+                type: typeof p.value === "number" ? "number" : "string",
+                description: `Parameter: ${p.key}`,
+                required: true
+              })),
+              returnType: "unknown",
+              source: "domain-block"
+            });
+          }
+        }
+        return {
+          name,
+          role: "domain-specialist",
+          modelConfig,
+          tools,
+          behaviors: [],
+          stateProperties: [],
+          dialogueHandlers: []
+        };
+      }
+      isAgentDomainBlock(block) {
+        const agentBlockTypes = ["agent_block", "inference_block", "ai_block"];
+        return agentBlockTypes.includes(block.blockType ?? "");
+      }
+      parseToolTrait(trait) {
+        const name = this.extractStringValue(trait.config["name"]) ?? "unnamed_tool";
+        const description = this.extractStringValue(trait.config["description"]) ?? "";
+        const parameters = [];
+        const paramsValue = trait.config["parameters"];
+        if (Array.isArray(paramsValue)) {
+          for (const param of paramsValue) {
+            if (param && typeof param === "object" && !Array.isArray(param)) {
+              const paramObj = param;
+              parameters.push({
+                name: this.extractStringValue(paramObj["name"]) ?? "param",
+                type: this.extractStringValue(paramObj["type"]) ?? "string",
+                description: this.extractStringValue(paramObj["description"]) ?? "",
+                required: paramObj["required"] === true,
+                defaultValue: paramObj["default"] != null ? String(paramObj["default"]) : void 0
+              });
+            }
+          }
+        }
+        return {
+          name,
+          description,
+          parameters,
+          returnType: this.extractStringValue(trait.config["returns"]) ?? "string",
+          source: "trait"
+        };
+      }
+      parseBehaviorAsTool(behavior) {
+        return {
+          name: this.toSnakeCase(behavior.name),
+          description: `Behavior: ${behavior.name} (triggered by: ${behavior.trigger})`,
+          parameters: behavior.actions.map((a) => ({
+            name: a.actionType,
+            type: "string",
+            description: `Action: ${a.actionType}`,
+            required: false
+          })),
+          returnType: "void",
+          source: "behavior"
+        };
+      }
+      createDefaultAgent(composition) {
+        return {
+          name: composition.name,
+          role: "assistant",
+          modelConfig: {
+            ...DEFAULT_MODEL_CONFIG,
+            provider: this.options.defaultProvider,
+            name: this.options.defaultModel,
+            temperature: this.options.defaultTemperature,
+            maxTokens: this.options.defaultMaxTokens,
+            systemPrompt: `You are an AI agent for ${composition.name}.`
+          },
+          tools: [],
+          behaviors: [],
+          stateProperties: [],
+          dialogueHandlers: []
+        };
+      }
+      applyModelConfig(trait, config) {
+        const provider = this.extractStringValue(trait.config["provider"]);
+        if (provider && this.isModelProvider(provider)) {
+          config.provider = provider;
+        }
+        config.name = this.extractStringValue(trait.config["name"]) ?? config.name;
+        config.temperature = this.extractNumberValue(trait.config["temperature"]) ?? config.temperature;
+        config.maxTokens = this.extractNumberValue(trait.config["max_tokens"]) ?? this.extractNumberValue(trait.config["maxTokens"]) ?? config.maxTokens;
+        config.topP = this.extractNumberValue(trait.config["top_p"]) ?? config.topP;
+        config.topK = this.extractNumberValue(trait.config["top_k"]) ?? config.topK;
+        const systemPrompt = this.extractStringValue(trait.config["system_prompt"]);
+        if (systemPrompt) {
+          config.systemPrompt = systemPrompt;
+        }
+      }
+      // ─── Code Generation (TypeScript) ───────────────────────────────────
+      emitAgentScript(compositionName) {
+        if (this.options.language === "python") {
+          return this.emitAgentScriptPython(compositionName);
+        }
+        return this.emitAgentScriptTypeScript(compositionName);
+      }
+      emitAgentScriptTypeScript(compositionName) {
+        const lines = [];
+        lines.push("/**");
+        lines.push(` * ${compositionName} \u2014 Agent Inference Script`);
+        lines.push(" * Generated by HoloScript AgentInferenceCompiler");
+        lines.push(" */");
+        lines.push("");
+        lines.push("import Anthropic from '@anthropic-ai/sdk';");
+        lines.push("import { tools, type ToolName, executeToolCall } from './tools';");
+        lines.push("import config from './config.json';");
+        if (this.options.includeTypes) {
+          lines.push("import type { AgentConfig, AgentState, Message } from './types';");
+        }
+        lines.push("");
+        for (const agent of this.agents) {
+          lines.push(`// \u2500\u2500\u2500 ${agent.name} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+          lines.push("");
+          lines.push(`export class ${this.toPascalCase(agent.name)}Agent {`);
+          lines.push("  private client: Anthropic;");
+          lines.push("  private messages: Anthropic.MessageParam[] = [];");
+          lines.push(`  private systemPrompt: string;`);
+          lines.push("");
+          if (agent.stateProperties.length > 0) {
+            lines.push("  // Agent state");
+            for (const prop of agent.stateProperties) {
+              const tsType = prop.type === "number" ? "number" : prop.type === "boolean" ? "boolean" : "string";
+              lines.push(`  private ${prop.key}: ${tsType} = ${JSON.stringify(prop.defaultValue)};`);
+            }
+            lines.push("");
+          }
+          lines.push("  constructor(apiKey?: string) {");
+          lines.push(
+            "    this.client = new Anthropic({ apiKey: apiKey ?? process.env['ANTHROPIC_API_KEY'] });"
+          );
+          lines.push(`    this.systemPrompt = ${JSON.stringify(agent.modelConfig.systemPrompt)};`);
+          lines.push("  }");
+          lines.push("");
+          lines.push("  async run(userMessage: string): Promise<string> {");
+          lines.push("    this.messages.push({ role: 'user', content: userMessage });");
+          lines.push("");
+          lines.push("    const response = await this.client.messages.create({");
+          lines.push(`      model: ${JSON.stringify(agent.modelConfig.name)},`);
+          lines.push(`      max_tokens: ${agent.modelConfig.maxTokens},`);
+          if (modelAcceptsSamplingParams(agent.modelConfig.name)) {
+            lines.push(`      temperature: ${agent.modelConfig.temperature},`);
+            lines.push(`      top_p: ${agent.modelConfig.topP},`);
+          }
+          lines.push("      system: this.systemPrompt,");
+          lines.push("      messages: this.messages,");
+          if (agent.tools.length > 0) {
+            lines.push("      tools,");
+          }
+          lines.push("    });");
+          lines.push("");
+          if (agent.tools.length > 0) {
+            lines.push("    // Handle tool use loop");
+            lines.push("    let currentResponse = response;");
+            lines.push("    while (currentResponse.stop_reason === 'tool_use') {");
+            lines.push("      const toolUseBlocks = currentResponse.content.filter(");
+            lines.push("        (block): block is Anthropic.ToolUseBlock => block.type === 'tool_use'");
+            lines.push("      );");
+            lines.push("");
+            lines.push("      const toolResults: Anthropic.ToolResultBlockParam[] = [];");
+            lines.push("      for (const toolUse of toolUseBlocks) {");
+            lines.push("        const result = await executeToolCall(");
+            lines.push("          toolUse.name as ToolName,");
+            lines.push("          toolUse.input as Record<string, unknown>");
+            lines.push("        );");
+            lines.push("        toolResults.push({");
+            lines.push("          type: 'tool_result',");
+            lines.push("          tool_use_id: toolUse.id,");
+            lines.push(
+              "          content: typeof result === 'string' ? result : JSON.stringify(result),"
+            );
+            lines.push("        });");
+            lines.push("      }");
+            lines.push("");
+            lines.push(
+              "      this.messages.push({ role: 'assistant', content: currentResponse.content });"
+            );
+            lines.push("      this.messages.push({ role: 'user', content: toolResults });");
+            lines.push("");
+            lines.push("      currentResponse = await this.client.messages.create({");
+            lines.push(`        model: ${JSON.stringify(agent.modelConfig.name)},`);
+            lines.push(`        max_tokens: ${agent.modelConfig.maxTokens},`);
+            if (modelAcceptsSamplingParams(agent.modelConfig.name)) {
+              lines.push(`        temperature: ${agent.modelConfig.temperature},`);
+            }
+            lines.push("        system: this.systemPrompt,");
+            lines.push("        messages: this.messages,");
+            lines.push("        tools,");
+            lines.push("      });");
+            lines.push("    }");
+            lines.push("");
+            lines.push(
+              "    this.messages.push({ role: 'assistant', content: currentResponse.content });"
+            );
+            lines.push("    const textBlocks = currentResponse.content.filter(");
+            lines.push("      (block): block is Anthropic.TextBlock => block.type === 'text'");
+            lines.push("    );");
+            lines.push("    return textBlocks.map((b) => b.text).join('\\n');");
+          } else {
+            lines.push("    this.messages.push({ role: 'assistant', content: response.content });");
+            lines.push("    const textBlocks = response.content.filter(");
+            lines.push("      (block): block is Anthropic.TextBlock => block.type === 'text'");
+            lines.push("    );");
+            lines.push("    return textBlocks.map((b) => b.text).join('\\n');");
+          }
+          lines.push("  }");
+          lines.push("");
+          lines.push("  reset(): void {");
+          lines.push("    this.messages = [];");
+          lines.push("  }");
+          lines.push("}");
+          lines.push("");
+        }
+        lines.push("// \u2500\u2500\u2500 Main \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+        lines.push("");
+        const primaryAgent = this.agents[0];
+        lines.push("async function main(): Promise<void> {");
+        lines.push(`  const agent = new ${this.toPascalCase(primaryAgent.name)}Agent();`);
+        lines.push("");
+        lines.push("  // Interactive loop (stdin/stdout)");
+        lines.push("  const readline = await import('readline');");
+        lines.push("  const rl = readline.createInterface({");
+        lines.push("    input: process.stdin,");
+        lines.push("    output: process.stdout,");
+        lines.push("  });");
+        lines.push("");
+        lines.push(
+          `  console.log('${this.escapeStringValue(compositionName, "TypeScript")} agent ready. Type a message or "quit" to exit.');`
+        );
+        lines.push("");
+        lines.push("  const ask = (): void => {");
+        lines.push("    rl.question('> ', async (input: string) => {");
+        lines.push("      if (input.trim().toLowerCase() === 'quit') {");
+        lines.push("        rl.close();");
+        lines.push("        return;");
+        lines.push("      }");
+        lines.push("      try {");
+        lines.push("        const response = await agent.run(input);");
+        lines.push("        console.log(response);");
+        lines.push("      } catch (err) {");
+        lines.push("        console.error('Error:', err);");
+        lines.push("      }");
+        lines.push("      ask();");
+        lines.push("    });");
+        lines.push("  };");
+        lines.push("  ask();");
+        lines.push("}");
+        lines.push("");
+        lines.push("main().catch(console.error);");
+        return lines.join("\n");
+      }
+      // ─── Code Generation (Python) ───────────────────────────────────────
+      emitAgentScriptPython(compositionName) {
+        const lines = [];
+        lines.push('"""');
+        lines.push(`${compositionName} \u2014 Agent Inference Script`);
+        lines.push("Generated by HoloScript AgentInferenceCompiler");
+        lines.push('"""');
+        lines.push("");
+        lines.push("import os");
+        lines.push("import json");
+        lines.push("import anthropic");
+        lines.push("from tools import TOOLS, execute_tool_call");
+        lines.push("");
+        for (const agent of this.agents) {
+          const className = this.toPascalCase(agent.name);
+          lines.push("");
+          lines.push(`class ${className}Agent:`);
+          lines.push(`    """${agent.role} agent."""`);
+          lines.push("");
+          lines.push("    def __init__(self, api_key: str | None = None):");
+          lines.push("        self.client = anthropic.Anthropic(");
+          lines.push("            api_key=api_key or os.environ.get('ANTHROPIC_API_KEY')");
+          lines.push("        )");
+          lines.push(`        self.system_prompt = ${JSON.stringify(agent.modelConfig.systemPrompt)}`);
+          lines.push("        self.messages: list[dict] = []");
+          for (const prop of agent.stateProperties) {
+            lines.push(`        self.${prop.key} = ${JSON.stringify(prop.defaultValue)}`);
+          }
+          lines.push("");
+          lines.push("    def run(self, user_message: str) -> str:");
+          lines.push("        self.messages.append({'role': 'user', 'content': user_message})");
+          lines.push("");
+          lines.push("        response = self.client.messages.create(");
+          lines.push(`            model=${JSON.stringify(agent.modelConfig.name)},`);
+          lines.push(`            max_tokens=${agent.modelConfig.maxTokens},`);
+          if (modelAcceptsSamplingParams(agent.modelConfig.name)) {
+            lines.push(`            temperature=${agent.modelConfig.temperature},`);
+          }
+          lines.push("            system=self.system_prompt,");
+          lines.push("            messages=self.messages,");
+          if (agent.tools.length > 0) {
+            lines.push("            tools=TOOLS,");
+          }
+          lines.push("        )");
+          lines.push("");
+          if (agent.tools.length > 0) {
+            lines.push("        while response.stop_reason == 'tool_use':");
+            lines.push("            tool_results = []");
+            lines.push("            for block in response.content:");
+            lines.push("                if block.type == 'tool_use':");
+            lines.push("                    result = execute_tool_call(block.name, block.input)");
+            lines.push("                    tool_results.append({");
+            lines.push("                        'type': 'tool_result',");
+            lines.push("                        'tool_use_id': block.id,");
+            lines.push("                        'content': str(result),");
+            lines.push("                    })");
+            lines.push("");
+            lines.push(
+              "            self.messages.append({'role': 'assistant', 'content': response.content})"
+            );
+            lines.push("            self.messages.append({'role': 'user', 'content': tool_results})");
+            lines.push("");
+            lines.push("            response = self.client.messages.create(");
+            lines.push(`                model=${JSON.stringify(agent.modelConfig.name)},`);
+            lines.push(`                max_tokens=${agent.modelConfig.maxTokens},`);
+            if (modelAcceptsSamplingParams(agent.modelConfig.name)) {
+              lines.push(`                temperature=${agent.modelConfig.temperature},`);
+            }
+            lines.push("                system=self.system_prompt,");
+            lines.push("                messages=self.messages,");
+            lines.push("                tools=TOOLS,");
+            lines.push("            )");
+            lines.push("");
+          }
+          lines.push(
+            "        self.messages.append({'role': 'assistant', 'content': response.content})"
+          );
+          lines.push("        text_blocks = [b.text for b in response.content if b.type == 'text']");
+          lines.push("        return '\\n'.join(text_blocks)");
+          lines.push("");
+          lines.push("    def reset(self):");
+          lines.push("        self.messages = []");
+          lines.push("");
+        }
+        const primaryAgent = this.agents[0];
+        lines.push("");
+        lines.push("if __name__ == '__main__':");
+        lines.push(`    agent = ${this.toPascalCase(primaryAgent.name)}Agent()`);
+        lines.push(
+          `    print('${this.escapeStringValue(compositionName, "Python")} agent ready. Type a message or "quit" to exit.')`
+        );
+        lines.push("    while True:");
+        lines.push("        user_input = input('> ')");
+        lines.push("        if user_input.strip().lower() == 'quit':");
+        lines.push("            break");
+        lines.push("        try:");
+        lines.push("            print(agent.run(user_input))");
+        lines.push("        except Exception as e:");
+        lines.push("            print(f'Error: {e}')");
+        return lines.join("\n");
+      }
+      // ─── Tool Definitions ───────────────────────────────────────────────
+      emitToolDefinitions(allTools) {
+        const provider = this.options.defaultProvider ?? DEFAULT_MODEL_CONFIG.provider;
+        if (this.options.language === "python") {
+          return this.emitToolDefinitionsPython(allTools, provider);
+        }
+        return this.emitToolDefinitionsTypeScript(allTools, provider);
+      }
+      emitToolDefinitionsTypeScript(allTools, provider) {
+        const lines = [];
+        lines.push("/**");
+        lines.push(" * Tool definitions for agent inference");
+        lines.push(` * Generated by HoloScript AgentInferenceCompiler (target: ${provider})`);
+        lines.push(" */");
+        lines.push("");
+        if (provider === "anthropic") {
+          lines.push("import Anthropic from '@anthropic-ai/sdk';");
+        }
+        lines.push("");
+        const toolNames = allTools.map((t) => `'${t.name}'`);
+        lines.push(`export type ToolName = ${toolNames.join(" | ")};`);
+        lines.push("");
+        if (provider === "anthropic") {
+          lines.push("export const tools: Anthropic.Tool[] = [");
+          for (const tool of allTools) {
+            lines.push("  {");
+            lines.push(`    name: ${JSON.stringify(tool.name)},`);
+            lines.push(`    description: ${JSON.stringify(tool.description)},`);
+            lines.push("    input_schema: {");
+            lines.push("      type: 'object' as const,");
+            lines.push("      properties: {");
+            for (const param of tool.parameters) {
+              lines.push(`        ${param.name}: {`);
+              lines.push(`          type: ${JSON.stringify(this.toJsonSchemaType(param.type))},`);
+              lines.push(`          description: ${JSON.stringify(param.description)},`);
+              lines.push("        },");
+            }
+            lines.push("      },");
+            const required = tool.parameters.filter((p) => p.required).map((p) => `'${p.name}'`);
+            if (required.length > 0) {
+              lines.push(`      required: [${required.join(", ")}],`);
+            }
+            lines.push("    },");
+            lines.push("  },");
+          }
+          lines.push("];");
+        } else if (provider === "custom") {
+          lines.push("export const tools = [");
+          for (const tool of allTools) {
+            lines.push("  {");
+            lines.push(`    name: ${JSON.stringify(tool.name)},`);
+            lines.push(`    description: ${JSON.stringify(tool.description)},`);
+            lines.push("    parameters: {");
+            lines.push("      type: 'object' as const,");
+            lines.push("      properties: {");
+            for (const param of tool.parameters) {
+              lines.push(`        ${param.name}: {`);
+              lines.push(`          type: ${JSON.stringify(this.toJsonSchemaType(param.type))},`);
+              lines.push(`          description: ${JSON.stringify(param.description)},`);
+              lines.push("        },");
+            }
+            lines.push("      },");
+            const required = tool.parameters.filter((p) => p.required).map((p) => `'${p.name}'`);
+            if (required.length > 0) {
+              lines.push(`      required: [${required.join(", ")}] as const,`);
+            }
+            lines.push("    },");
+            lines.push("  },");
+          }
+          lines.push("] as const;");
+        } else {
+          lines.push("export const tools = [");
+          for (const tool of allTools) {
+            lines.push("  {");
+            lines.push("    type: 'function' as const,");
+            lines.push(`    name: ${JSON.stringify(tool.name)},`);
+            lines.push(`    description: ${JSON.stringify(tool.description)},`);
+            lines.push("    parameters: {");
+            lines.push("      type: 'object' as const,");
+            lines.push("      properties: {");
+            for (const param of tool.parameters) {
+              lines.push(`        ${param.name}: {`);
+              lines.push(`          type: ${JSON.stringify(this.toJsonSchemaType(param.type))},`);
+              lines.push(`          description: ${JSON.stringify(param.description)},`);
+              lines.push("        },");
+            }
+            lines.push("      },");
+            const required = tool.parameters.filter((p) => p.required).map((p) => `'${p.name}'`);
+            if (required.length > 0) {
+              lines.push(`      required: [${required.join(", ")}] as const,`);
+            }
+            lines.push("    },");
+            lines.push("  },");
+          }
+          lines.push("] as const;");
+        }
+        lines.push("");
+        lines.push("export async function executeToolCall(");
+        lines.push("  name: ToolName,");
+        lines.push("  input: Record<string, unknown>");
+        lines.push("): Promise<unknown> {");
+        lines.push("  switch (name) {");
+        for (const tool of allTools) {
+          lines.push(`    case ${JSON.stringify(tool.name)}:`);
+          lines.push(`      // Stub: ${tool.name} (generated dispatcher)`);
+          lines.push(`      return \`[${tool.name}] called with: \${JSON.stringify(input)}\`;`);
+        }
+        lines.push("    default:");
+        lines.push("      return `Unknown tool: ${name}`;");
+        lines.push("  }");
+        lines.push("}");
+        return lines.join("\n");
+      }
+      emitToolDefinitionsPython(allTools, provider) {
+        const lines = [];
+        lines.push('"""');
+        lines.push("Tool definitions for agent inference");
+        lines.push(`Generated by HoloScript AgentInferenceCompiler (target: ${provider})`);
+        lines.push('"""');
+        lines.push("");
+        lines.push("");
+        lines.push("TOOLS = [");
+        for (const tool of allTools) {
+          lines.push("    {");
+          if (provider !== "anthropic" && provider !== "custom") {
+            lines.push('        "type": "function",');
+          }
+          lines.push(`        "name": ${JSON.stringify(tool.name)},`);
+          lines.push(`        "description": ${JSON.stringify(tool.description)},`);
+          const paramKey = provider === "anthropic" ? "input_schema" : "parameters";
+          lines.push(`        ${JSON.stringify(paramKey)}: {`);
+          lines.push('            "type": "object",');
+          lines.push('            "properties": {');
+          for (const param of tool.parameters) {
+            lines.push(`                ${JSON.stringify(param.name)}: {`);
+            lines.push(
+              `                    "type": ${JSON.stringify(this.toJsonSchemaType(param.type))},`
+            );
+            lines.push(`                    "description": ${JSON.stringify(param.description)},`);
+            lines.push("                },");
+          }
+          lines.push("            },");
+          const required = tool.parameters.filter((p) => p.required).map((p) => JSON.stringify(p.name));
+          if (required.length > 0) {
+            lines.push(`            "required": [${required.join(", ")}],`);
+          }
+          lines.push("        },");
+          lines.push("    },");
+        }
+        lines.push("]");
+        lines.push("");
+        lines.push("");
+        lines.push("def execute_tool_call(name: str, tool_input: dict) -> str:");
+        for (const tool of allTools) {
+          lines.push(`    if name == ${JSON.stringify(tool.name)}:`);
+          lines.push(`        # Stub: ${tool.name} (generated dispatcher)`);
+          lines.push(`        return f"[${tool.name}] called with: {tool_input}"`);
+        }
+        lines.push(`    return f"Unknown tool: {name}"`);
+        return lines.join("\n");
+      }
+      // ─── Config & Package Files ─────────────────────────────────────────
+      emitConfigJson() {
+        const configs = this.agents.map((a) => ({
+          name: a.name,
+          role: a.role,
+          model: {
+            provider: a.modelConfig.provider,
+            name: a.modelConfig.name,
+            temperature: a.modelConfig.temperature,
+            max_tokens: a.modelConfig.maxTokens,
+            top_p: a.modelConfig.topP,
+            top_k: a.modelConfig.topK
+          },
+          system_prompt: a.modelConfig.systemPrompt,
+          tools: a.tools.map((t) => t.name)
+        }));
+        return JSON.stringify({ agents: configs }, null, 2);
+      }
+      emitPackageJson(compositionName) {
+        const pkg = {
+          name: this.toKebabCase(compositionName) + "-agent",
+          version: "1.0.0",
+          description: `Agent inference script for ${compositionName}`,
+          type: "module",
+          scripts: {
+            start: "tsx agent.ts",
+            build: "tsc"
+          },
+          dependencies: {
+            // Floor bumped to support adaptive thinking, output_config.effort,
+            // and Opus 4.7 sampling-param removal. Keep in sync with
+            // packages/llm-provider/package.json to avoid split versions.
+            "@anthropic-ai/sdk": "^0.88.0"
+          },
+          devDependencies: {
+            tsx: "^4.0.0",
+            typescript: "^5.5.0",
+            "@types/node": "^20.0.0"
+          }
+        };
+        const providers = new Set(this.agents.map((a) => a.modelConfig.provider));
+        if (providers.has("openai")) {
+          pkg.dependencies = { ...pkg.dependencies, openai: "^4.0.0" };
+        }
+        return JSON.stringify(pkg, null, 2);
+      }
+      emitRequirementsTxt() {
+        const deps = ["anthropic>=0.39.0"];
+        const providers = new Set(this.agents.map((a) => a.modelConfig.provider));
+        if (providers.has("openai")) {
+          deps.push("openai>=1.0.0");
+        }
+        return deps.join("\n") + "\n";
+      }
+      emitEnvTemplate() {
+        const lines = [];
+        lines.push("# Agent API Keys");
+        const providers = new Set(this.agents.map((a) => a.modelConfig.provider));
+        if (providers.has("anthropic")) {
+          lines.push("ANTHROPIC_API_KEY=sk-ant-...");
+        }
+        if (providers.has("openai")) {
+          lines.push("OPENAI_API_KEY=sk-...");
+        }
+        if (providers.has("ollama")) {
+          lines.push("OLLAMA_HOST=http://localhost:11434");
+        }
+        return lines.join("\n") + "\n";
+      }
+      emitTypeDefinitions() {
+        return `/**
+ * Type definitions for agent inference
+ * Generated by HoloScript AgentInferenceCompiler
+ */
+
+export interface AgentConfig {
+  name: string;
+  role: string;
+  model: {
+    provider: string;
+    name: string;
+    temperature: number;
+    max_tokens: number;
+    top_p: number;
+    top_k: number;
+  };
+  system_prompt: string;
+  tools: string[];
+}
+
+export interface AgentState {
+  [key: string]: string | number | boolean;
+}
+
+export interface Message {
+  role: 'user' | 'assistant';
+  content: string;
+}
+
+export interface ToolResult {
+  tool_use_id: string;
+  content: string;
+}
+`;
+      }
+      emitReadme(compositionName) {
+        this.options.language === "typescript" ? "ts" : "py";
+        const lines = [];
+        lines.push(`# ${compositionName} Agent`);
+        lines.push("");
+        lines.push("Generated by HoloScript AgentInferenceCompiler.");
+        lines.push("");
+        lines.push("## Setup");
+        lines.push("");
+        if (this.options.language === "typescript") {
+          lines.push("```bash");
+          lines.push("npm install");
+          lines.push("cp .env.example .env");
+          lines.push("# Edit .env with your API key");
+          lines.push("npm start");
+          lines.push("```");
+        } else {
+          lines.push("```bash");
+          lines.push("pip install -r requirements.txt");
+          lines.push("cp .env.example .env");
+          lines.push("# Edit .env with your API key");
+          lines.push(`python agent.py`);
+          lines.push("```");
+        }
+        lines.push("");
+        lines.push("## Agents");
+        lines.push("");
+        for (const agent of this.agents) {
+          lines.push(`### ${agent.name}`);
+          lines.push(`- **Role**: ${agent.role}`);
+          lines.push(`- **Model**: ${agent.modelConfig.name}`);
+          lines.push(
+            `- **Tools**: ${agent.tools.length > 0 ? agent.tools.map((t) => t.name).join(", ") : "none"}`
+          );
+          lines.push("");
+        }
+        return lines.join("\n");
+      }
+      // ─── Helpers ────────────────────────────────────────────────────────
+      extractStringValue(value) {
+        if (typeof value === "string") return value;
+        return null;
+      }
+      extractNumberValue(value) {
+        if (typeof value === "number") return value;
+        return null;
+      }
+      isModelProvider(value) {
+        return ["anthropic", "openai", "local", "ollama", "custom"].includes(value);
+      }
+      toJsonSchemaType(type) {
+        switch (type.toLowerCase()) {
+          case "number":
+          case "float":
+          case "int":
+          case "integer":
+            return "number";
+          case "boolean":
+          case "bool":
+            return "boolean";
+          case "array":
+          case "list":
+            return "array";
+          case "object":
+          case "dict":
+          case "map":
+            return "object";
+          default:
+            return "string";
+        }
+      }
+      toPascalCase(name) {
+        return name.replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (_, c) => c.toUpperCase());
+      }
+      toSnakeCase(name) {
+        return name.replace(/([A-Z])/g, "_$1").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_/, "").toLowerCase();
+      }
+      toKebabCase(name) {
+        return name.replace(/([A-Z])/g, "-$1").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-/, "").toLowerCase();
+      }
+    };
+    exports.AgentInferenceExportTarget_default = exports.AgentInferenceCompiler;
+  }
+});
+
+exports.AgentInferenceExportTarget_exports = AgentInferenceExportTarget_exports;
+exports.createAgentInferenceCompiler = createAgentInferenceCompiler;
+exports.createPythonAgentInferenceCompiler = createPythonAgentInferenceCompiler;
+exports.init_AgentInferenceExportTarget = init_AgentInferenceExportTarget;
+//# sourceMappingURL=chunk-BCP4E7MD.cjs.map
+//# sourceMappingURL=chunk-BCP4E7MD.cjs.map