@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-JC5YBPSF.cjs

@@ -0,0 +1,984 @@
+'use strict';
+
+var chunkKKP7JKN4_cjs = require('./chunk-KKP7JKN4.cjs');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/AgentInferenceExportTarget.ts
+chunkKKP7JKN4_cjs.init_CompilerBase();
+var 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."
+};
+var ANTHROPIC_MODELS_NO_SAMPLING_PARAMS = /* @__PURE__ */ new Set(["claude-opus-4-7"]);
+function modelAcceptsSamplingParams(modelName) {
+  return !ANTHROPIC_MODELS_NO_SAMPLING_PARAMS.has(modelName);
+}
+var 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"
+]);
+var AgentInferenceCompiler = class extends chunkKKP7JKN4_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();
+  }
+};
+function createAgentInferenceCompiler(options) {
+  return new AgentInferenceCompiler(options);
+}
+function createPythonAgentInferenceCompiler(options) {
+  return new AgentInferenceCompiler({ ...options, language: "python" });
+}
+var AgentInferenceExportTarget_default = AgentInferenceCompiler;
+
+exports.AgentInferenceCompiler = AgentInferenceCompiler;
+exports.AgentInferenceExportTarget_default = AgentInferenceExportTarget_default;
+exports.createAgentInferenceCompiler = createAgentInferenceCompiler;
+exports.createPythonAgentInferenceCompiler = createPythonAgentInferenceCompiler;
+//# sourceMappingURL=chunk-JC5YBPSF.cjs.map
+//# sourceMappingURL=chunk-JC5YBPSF.cjs.map