{"version":3,"file":"index.cjs","names":["__dirname","path","constants","response: SwiftResponse<T>","response: SwiftResponse<{ chunk: string; done: boolean }>","message: Message","chunks: string[]","error: Error | null"],"sources":["../src/executor.ts","../src/executors/process-per-call.ts","../src/executors/persistent-server.ts","../src/types.ts","../src/foundation-models.ts"],"sourcesContent":["import { spawn } from 'child_process';\nimport { join, dirname, resolve } from 'path';\nimport { fileURLToPath } from 'url';\nimport { accessSync, constants, existsSync, readFileSync } from 'fs';\nimport type { SwiftResponse } from './types.js';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\n/**\n * Find the apple-foundation-models package root directory\n * This works even when the code is bundled into another package\n */\nfunction findPackageRoot(): string {\n  // Start from current directory and walk up to find node_modules/apple-foundation-models\n  let currentDir = __dirname;\n\n  // Try up to 10 levels up (should be more than enough)\n  for (let i = 0; i < 10; i++) {\n    // Check if we're inside apple-foundation-models package\n    const packageJsonPath = join(currentDir, 'package.json');\n    if (existsSync(packageJsonPath)) {\n      try {\n        // On some systems, we might not have read permission, so wrap in try-catch\n        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));\n        if (packageJson.name === 'apple-foundation-models') {\n          return currentDir;\n        }\n      } catch {\n        // Ignore and continue searching\n      }\n    }\n\n    // Check for node_modules/apple-foundation-models\n    const nodeModulesPath = join(currentDir, 'node_modules', 'apple-foundation-models');\n    if (existsSync(nodeModulesPath)) {\n      return nodeModulesPath;\n    }\n\n    // Move up one directory\n    const parentDir = dirname(currentDir);\n    if (parentDir === currentDir) {\n      // Reached root, can't go further\n      break;\n    }\n    currentDir = parentDir;\n  }\n\n  // Fallback to relative path from __dirname (works in non-bundled scenarios)\n  return join(__dirname, '..');\n}\n\n/**\n * Get the path to the Swift executable\n */\nexport function getSwiftExecutablePath(): string {\n  // Swift Package Manager creates architecture-specific directories\n  // Format: .build/{arch}-{os}-{sdk}/{configuration}/ExecutableName\n  const arch = process.arch === 'arm64' ? 'arm64' : 'x86_64';\n  const platform = `${arch}-apple-macosx`;\n\n  // Find the package root (works even when bundled)\n  const packageRoot = findPackageRoot();\n\n  // Build paths relative to package root\n  const productionArchPath = join(packageRoot, 'swift', '.build', platform, 'release', 'AppleFoundationModelsWrapper');\n  const debugArchPath = join(packageRoot, 'swift', '.build', platform, 'debug', 'AppleFoundationModelsWrapper');\n  const productionPath = join(packageRoot, 'swift', '.build', 'release', 'AppleFoundationModelsWrapper');\n  const debugPath = join(packageRoot, 'swift', '.build', 'debug', 'AppleFoundationModelsWrapper');\n\n  // Try paths in order: production with arch, debug with arch, production without arch, debug without arch\n  const paths = [productionArchPath, debugArchPath, productionPath, debugPath];\n\n  for (const path of paths) {\n    try {\n      accessSync(path, constants.X_OK);\n      return path;\n    } catch {\n      // Try next path\n    }\n  }\n\n  // If none found, return the first path (will fail with better error message)\n  return productionArchPath;\n}\n\n/**\n * Execute a command via the Swift wrapper\n */\nexport async function executeSwiftCommand<T = any>(\n  action: string,\n  parameters?: Record<string, any>\n): Promise<T> {\n  const executablePath = getSwiftExecutablePath();\n\n  const command = {\n    action,\n    parameters: parameters || {},\n  };\n\n  const commandJson = JSON.stringify(command);\n\n  return new Promise((resolve, reject) => {\n    const child = spawn(executablePath, [], {\n      stdio: ['pipe', 'pipe', 'pipe'],\n    });\n\n    let stdout = '';\n    let stderr = '';\n\n    child.stdout.on('data', (data) => {\n      stdout += data.toString();\n    });\n\n    child.stderr.on('data', (data) => {\n      stderr += data.toString();\n    });\n\n    child.on('error', (error) => {\n      reject(new Error(`Failed to spawn Swift process: ${error.message}`));\n    });\n\n    child.on('close', (code) => {\n      if (stderr) {\n        console.error('Swift stderr:', stderr);\n      }\n\n      if (code !== 0) {\n        reject(new Error(`Swift process exited with code ${code}`));\n        return;\n      }\n\n      try {\n        const response: SwiftResponse<T> = JSON.parse(stdout);\n\n        if (!response.success) {\n          reject(new Error(response.error || 'Unknown error from Swift wrapper'));\n          return;\n        }\n\n        resolve(response.data as T);\n      } catch (error) {\n        reject(new Error(`Failed to parse Swift response: ${error instanceof Error ? error.message : 'Unknown error'}`));\n      }\n    });\n\n    // Write command to stdin and close\n    child.stdin.write(commandJson + '\\n');\n    child.stdin.end();\n  });\n}\n\n/**\n * Execute a streaming command via the Swift wrapper\n * Yields chunks as they arrive\n *\n * IMPLEMENTATION NOTE: This function reads stdout line-by-line, parsing each line\n * as a separate JSON response. The Swift wrapper outputs single-line JSON for each\n * chunk (using printCompactResponse) to enable this streaming architecture.\n * Protocol: {\"success\":true,\"data\":{\"chunk\":\"text\",\"done\":false}}\n */\nexport async function* executeSwiftStreamCommand(\n  action: string,\n  parameters?: Record<string, any>\n): AsyncIterableIterator<string> {\n  const executablePath = getSwiftExecutablePath();\n\n  const command = {\n    action,\n    parameters: parameters || {},\n  };\n\n  const commandJson = JSON.stringify(command);\n\n  const child = spawn(executablePath, [], {\n    stdio: ['pipe', 'pipe', 'pipe'],\n  });\n\n  let stderr = '';\n  let buffer = '';\n\n  child.stderr.on('data', (data) => {\n    stderr += data.toString();\n  });\n\n  // Write command to stdin and close\n  child.stdin.write(commandJson + '\\n');\n  child.stdin.end();\n\n  // Process stdout line by line\n  for await (const data of child.stdout) {\n    buffer += data.toString();\n\n    // Split by newlines and process complete lines\n    const lines = buffer.split('\\n');\n    buffer = lines.pop() || ''; // Keep incomplete line in buffer\n\n    for (const line of lines) {\n      if (!line.trim()) continue;\n\n      try {\n        const response: SwiftResponse<{ chunk: string; done: boolean }> = JSON.parse(line);\n\n        if (!response.success) {\n          throw new Error(response.error || 'Unknown error from Swift wrapper');\n        }\n\n        if (response.data?.done) {\n          // Stream is complete\n          return;\n        }\n\n        if (response.data?.chunk) {\n          yield response.data.chunk;\n        }\n      } catch (error) {\n        throw new Error(`Failed to parse streaming response: ${error instanceof Error ? error.message : 'Unknown error'}`);\n      }\n    }\n  }\n\n  // Handle any remaining buffer\n  if (buffer.trim()) {\n    try {\n      const response: SwiftResponse<{ chunk: string; done: boolean }> = JSON.parse(buffer);\n      if (!response.success) {\n        throw new Error(response.error || 'Unknown error from Swift wrapper');\n      }\n    } catch (error) {\n      // Ignore parse errors for the final buffer\n    }\n  }\n\n  // Check for process errors\n  const exitCode = await new Promise<number | null>((resolve) => {\n    child.on('close', resolve);\n  });\n\n  if (stderr) {\n    console.error('Swift stderr:', stderr);\n  }\n\n  if (exitCode !== 0) {\n    throw new Error(`Swift process exited with code ${exitCode}`);\n  }\n}\n","/**\n * Process-Per-Call Executor\n *\n * This is the original fast-path executor that spawns a new Swift process\n * for each operation. Used when tools are not needed.\n *\n * Performance characteristics:\n * - Latency: ~1.0s per call\n * - Stateless: No cleanup needed\n * - Isolated: Each call independent\n * - Simple: No connection management\n */\n\nimport { executeSwiftCommand, executeSwiftStreamCommand } from '../executor.js';\nimport type { Executor } from '../executor-interface.js';\n\nexport class ProcessPerCallExecutor implements Executor {\n  /**\n   * Execute a command via process-per-call pattern\n   * Spawns a new Swift process for each call\n   */\n  async execute<T = any>(action: string, parameters?: Record<string, any>): Promise<T> {\n    return executeSwiftCommand<T>(action, parameters);\n  }\n\n  /**\n   * Execute a streaming command via process-per-call pattern\n   * Spawns a new Swift process that streams results\n   */\n  async *executeStream(action: string, parameters?: Record<string, any>): AsyncIterableIterator<string> {\n    yield* executeSwiftStreamCommand(action, parameters);\n  }\n\n  /**\n   * Close the executor\n   * No-op for process-per-call since there's no persistent state\n   */\n  async close(): Promise<void> {\n    // Nothing to clean up\n  }\n}\n","/**\n * Persistent Server Executor\n *\n * This executor communicates with a long-lived Swift server process via\n * Unix domain socket and JSON-RPC protocol. Used when tools are needed\n * to enable bidirectional communication during generation.\n *\n * Performance characteristics:\n * - First call: ~1.2s (includes server startup)\n * - Subsequent calls: ~0.7s (no spawn overhead)\n * - Tool callbacks: Real-time bidirectional communication\n * - Cleanup required: Must call close() to shutdown server\n */\n\nimport { spawn, type ChildProcess } from 'child_process';\nimport net from 'net';\nimport { unlinkSync, existsSync } from 'fs';\nimport { randomUUID } from 'crypto';\nimport readline from 'readline';\nimport type { Executor } from '../executor-interface.js';\nimport type { Tool, ToolOutput, SwiftResponse } from '../types.js';\nimport { getSwiftExecutablePath } from '../executor.js';\n\ninterface Message {\n  jsonrpc: '2.0';\n  id?: string;\n  method?: string;\n  params?: any;\n  result?: any;\n  error?: { code: number; message: string };\n}\n\n// Counter to ensure unique socket paths even within same millisecond\nlet socketCounter = 0;\n\nexport class PersistentServerExecutor implements Executor {\n  private socket?: net.Socket;\n  private serverProcess?: ChildProcess;\n  private tools: Map<string, Tool>;\n  private socketPath: string;\n  private messageHandlers: Map<string, (data: any) => void> = new Map();\n  private connected: boolean = false;\n  private connecting: Promise<void> | null = null;\n\n  constructor(tools: Tool[]) {\n    this.tools = new Map(tools.map((t) => [t.name, t]));\n    // Use process PID, timestamp, and counter to ensure unique socket path\n    this.socketPath = `/tmp/afm-${process.pid}-${Date.now()}-${socketCounter++}.sock`;\n  }\n\n  /**\n   * Ensure connection to Swift server\n   * Starts server if not running and connects socket\n   */\n  private async ensureConnected(): Promise<void> {\n    if (this.connected && this.socket?.writable) {\n      return;\n    }\n\n    // Prevent multiple concurrent connection attempts\n    if (this.connecting) {\n      return this.connecting;\n    }\n\n    this.connecting = (async () => {\n      try {\n        // Start server if not running\n        if (!this.serverProcess || this.serverProcess.exitCode !== null) {\n          await this.startServer();\n        }\n\n        // Connect socket if not connected\n        if (!this.socket || !this.socket.writable) {\n          await this.connectSocket();\n        }\n\n        this.connected = true;\n      } finally {\n        this.connecting = null;\n      }\n    })();\n\n    return this.connecting;\n  }\n\n  /**\n   * Start the Swift server process\n   */\n  private async startServer(): Promise<void> {\n    const serverPath = getSwiftExecutablePath();\n\n    // Clean up old socket file if exists\n    if (existsSync(this.socketPath)) {\n      unlinkSync(this.socketPath);\n    }\n\n    // Spawn server process\n    this.serverProcess = spawn(serverPath, ['--persistent-server', '--socket', this.socketPath], {\n      stdio: ['ignore', 'pipe', 'pipe'],\n    });\n\n    // Log server stderr for debugging\n    if (this.serverProcess.stderr) {\n      const rl = readline.createInterface({ input: this.serverProcess.stderr });\n      rl.on('line', (line) => {\n        console.error('[Swift Server]:', line);\n      });\n    }\n\n    // Handle server exit\n    this.serverProcess.on('exit', (code) => {\n      console.error(`[Swift Server] Exited with code ${code}`);\n      this.connected = false;\n      this.socket?.destroy();\n      this.socket = undefined;\n    });\n\n    // Wait for socket file to be created (server is ready)\n    await this.waitForSocket(5000);\n  }\n\n  /**\n   * Wait for Unix socket file to exist\n   */\n  private async waitForSocket(timeoutMs: number): Promise<void> {\n    const startTime = Date.now();\n\n    while (!existsSync(this.socketPath)) {\n      if (Date.now() - startTime > timeoutMs) {\n        throw new Error(`Timeout waiting for server socket: ${this.socketPath}`);\n      }\n      await new Promise((resolve) => setTimeout(resolve, 50));\n    }\n\n    // Give server a moment to start listening\n    await new Promise((resolve) => setTimeout(resolve, 100));\n  }\n\n  /**\n   * Connect to the Unix socket\n   */\n  private async connectSocket(): Promise<void> {\n    this.socket = net.createConnection(this.socketPath);\n\n    // Set up message handler\n    let buffer = '';\n    this.socket.on('data', (data) => {\n      buffer += data.toString();\n\n      // Process complete lines (JSON-RPC messages)\n      const lines = buffer.split('\\n');\n      buffer = lines.pop() || '';\n\n      for (const line of lines) {\n        if (!line.trim()) continue;\n\n        try {\n          const message: Message = JSON.parse(line);\n          this.handleMessage(message);\n        } catch (error) {\n          console.error('[Socket] Failed to parse message:', error);\n        }\n      }\n    });\n\n    this.socket.on('error', (error) => {\n      console.error('[Socket] Error:', error);\n      this.connected = false;\n    });\n\n    this.socket.on('close', () => {\n      this.connected = false;\n    });\n\n    // Wait for connection\n    await new Promise<void>((resolve, reject) => {\n      this.socket!.once('connect', () => resolve());\n      this.socket!.once('error', (err) => reject(err));\n    });\n\n    // Send tool definitions to server\n    await this.sendToolDefinitions();\n  }\n\n  /**\n   * Send tool definitions to Swift server\n   */\n  private async sendToolDefinitions(): Promise<void> {\n    const toolDefs = Array.from(this.tools.values()).map((tool) => ({\n      name: tool.name,\n      description: tool.description,\n    }));\n\n    await this.sendRequest('registerTools', { tools: toolDefs });\n  }\n\n  /**\n   * Handle incoming message from Swift server\n   */\n  private async handleMessage(message: Message): Promise<void> {\n    // Tool call request from Swift\n    if (message.method === 'executeTool') {\n      await this.handleToolCall(message);\n      return;\n    }\n\n    // Response to a request we sent\n    if (message.id) {\n      const handler = this.messageHandlers.get(message.id);\n      if (handler) {\n        if (message.error) {\n          handler({ error: message.error.message });\n        } else {\n          handler({ result: message.result });\n        }\n        this.messageHandlers.delete(message.id);\n      }\n    }\n  }\n\n  /**\n   * Handle tool execution request from Swift\n   */\n  private async handleToolCall(message: Message): Promise<void> {\n    const { name, arguments: args } = message.params;\n    const tool = this.tools.get(name);\n\n    if (!tool) {\n      this.sendResponse(message.id!, {\n        error: { code: -32601, message: `Tool not found: ${name}` },\n      });\n      return;\n    }\n\n    try {\n      const result = await tool.call(args);\n\n      // Send result back to Swift\n      this.sendResponse(message.id!, {\n        result: result.value,\n      });\n    } catch (error) {\n      this.sendResponse(message.id!, {\n        error: {\n          code: -32603,\n          message: error instanceof Error ? error.message : 'Tool execution failed',\n        },\n      });\n    }\n  }\n\n  /**\n   * Send JSON-RPC request to Swift server\n   */\n  private async sendRequest<T>(method: string, params?: any): Promise<T> {\n    const id = randomUUID();\n\n    return new Promise((resolve, reject) => {\n      // Register handler for response\n      this.messageHandlers.set(id, (data) => {\n        if (data.error) {\n          reject(new Error(data.error));\n        } else {\n          resolve(data.result as T);\n        }\n      });\n\n      // Send request\n      const message: Message = {\n        jsonrpc: '2.0',\n        id,\n        method,\n        params,\n      };\n\n      this.socket!.write(JSON.stringify(message) + '\\n');\n\n      // Timeout after 30s\n      setTimeout(() => {\n        if (this.messageHandlers.has(id)) {\n          this.messageHandlers.delete(id);\n          reject(new Error('Request timeout'));\n        }\n      }, 30000);\n    });\n  }\n\n  /**\n   * Send JSON-RPC response to Swift server\n   */\n  private sendResponse(id: string, response: { result?: any; error?: any }): void {\n    const message: Message = {\n      jsonrpc: '2.0',\n      id,\n      ...response,\n    };\n\n    this.socket!.write(JSON.stringify(message) + '\\n');\n  }\n\n  /**\n   * Execute a command via persistent server\n   */\n  async execute<T = any>(action: string, parameters?: Record<string, any>): Promise<T> {\n    await this.ensureConnected();\n    return this.sendRequest<T>(action, parameters);\n  }\n\n  /**\n   * Execute a streaming command via persistent server\n   */\n  async *executeStream(action: string, parameters?: Record<string, any>): AsyncIterableIterator<string> {\n    await this.ensureConnected();\n\n    const id = randomUUID();\n    const chunks: string[] = [];\n    let done = false;\n    let error: Error | null = null;\n\n    // Register handler for streaming responses\n    this.messageHandlers.set(id, (data) => {\n      if (data.error) {\n        error = new Error(data.error);\n        done = true;\n      } else if (data.result?.done) {\n        done = true;\n      } else if (data.result?.chunk) {\n        chunks.push(data.result.chunk);\n      }\n    });\n\n    // Send streaming request\n    const message: Message = {\n      jsonrpc: '2.0',\n      id,\n      method: `${action}Stream`,\n      params: parameters,\n    };\n\n    this.socket!.write(JSON.stringify(message) + '\\n');\n\n    // Yield chunks as they arrive\n    while (!done) {\n      if (error) {\n        throw error;\n      }\n\n      if (chunks.length > 0) {\n        yield chunks.shift()!;\n      } else {\n        // Small delay to avoid busy-waiting\n        await new Promise((resolve) => setTimeout(resolve, 10));\n      }\n    }\n\n    // Yield any remaining chunks\n    while (chunks.length > 0) {\n      yield chunks.shift()!;\n    }\n\n    this.messageHandlers.delete(id);\n  }\n\n  /**\n   * Close the executor and clean up resources\n   * Shuts down Swift server and removes socket file\n   */\n  async close(): Promise<void> {\n    // Close socket\n    if (this.socket) {\n      this.socket.destroy();\n      this.socket = undefined;\n    }\n\n    // Terminate server process\n    if (this.serverProcess && this.serverProcess.exitCode === null) {\n      this.serverProcess.kill('SIGTERM');\n\n      // Wait for graceful shutdown with timeout\n      await Promise.race([\n        new Promise<void>((resolve) => {\n          this.serverProcess!.once('exit', () => resolve());\n        }),\n        new Promise<void>((resolve) => setTimeout(resolve, 2000)),\n      ]);\n\n      // Force kill if still alive\n      if (this.serverProcess.exitCode === null) {\n        this.serverProcess.kill('SIGKILL');\n      }\n\n      this.serverProcess = undefined;\n    }\n\n    // Clean up socket file\n    try {\n      if (existsSync(this.socketPath)) {\n        unlinkSync(this.socketPath);\n      }\n    } catch (error) {\n      // Ignore cleanup errors\n    }\n\n    this.connected = false;\n  }\n}\n","/**\n * Type definitions matching Apple's FoundationModels API\n */\n\n// ============================================================================\n// SystemLanguageModel Types\n// ============================================================================\n\n/**\n * Availability status of the system language model\n */\nexport enum Availability {\n  /** Model is available and ready to use */\n  Available = 'available',\n  /** Model is unavailable - device not eligible */\n  DeviceNotEligible = 'deviceNotEligible',\n  /** Model is unavailable - Apple Intelligence not enabled */\n  AppleIntelligenceNotEnabled = 'appleIntelligenceNotEnabled',\n  /** Model is unavailable - model not ready (downloading or initializing) */\n  ModelNotReady = 'modelNotReady',\n}\n\n/**\n * Use case for specialized language models\n */\nexport enum UseCase {\n  /** Specialized for content tagging, entity extraction, and topic detection */\n  ContentTagging = 'contentTagging',\n}\n\n/**\n * Represents a language model available in FoundationModels\n * (Used internally for compatibility)\n */\nexport interface LanguageModelInfo {\n  /** Unique identifier for the model */\n  id: string;\n  /** Human-readable name of the model */\n  name: string;\n  /** Maximum number of tokens the model can generate */\n  maxTokens: number;\n}\n\n// ============================================================================\n// LanguageModelSession Types\n// ============================================================================\n\n/**\n * Sampling mode for text generation\n */\nexport enum SamplingMode {\n  /** Deterministic - always picks highest probability token */\n  Greedy = 'greedy',\n  /** Random sampling from the probability distribution */\n  Random = 'random',\n}\n\n/**\n * Options for customizing text generation\n */\nexport interface GenerationOptions {\n  /** Sampling mode */\n  sampling?: SamplingMode;\n  /** Temperature for randomness/creativity (0.0 to 2.0) */\n  temperature?: number;\n  /** Maximum number of tokens to generate */\n  maximumResponseTokens?: number;\n}\n\n/**\n * Instructions provide context, role, and preferences for model responses\n */\nexport class Instructions {\n  readonly text!: string;\n\n  constructor(text: string) {\n    // Make text truly immutable at runtime\n    Object.defineProperty(this, 'text', {\n      value: text,\n      writable: false,\n      enumerable: true,\n      configurable: false,\n    });\n  }\n}\n\n/**\n * Guardrails for safety filtering\n */\nexport class Guardrails {\n  private static _default?: Guardrails;\n\n  static get default(): Guardrails {\n    if (!this._default) {\n      this._default = new Guardrails();\n    }\n    return this._default;\n  }\n\n  private constructor() {}\n}\n\n/**\n * Represents a tool call made by the model\n */\nexport interface ToolCall {\n  /** Name of the tool being called */\n  name: string;\n  /** Arguments passed to the tool (structured data) */\n  arguments: Record<string, any>;\n}\n\n/**\n * Entry in the conversation transcript\n */\nexport type TranscriptEntry =\n  | { type: 'prompt'; content: string }\n  | { type: 'response'; content: string }\n  | { type: 'instructions'; instructions: Instructions }\n  | { type: 'toolCalls'; calls: ToolCall[] }\n  | { type: 'toolOutput'; output: ToolOutput };\n\n/**\n * Response from the language model\n */\nexport interface Response<Content> {\n  /** The generated content */\n  content: Content;\n  /** The sequence of user and assistant messages */\n  transcriptEntries: TranscriptEntry[];\n}\n\n/**\n * Tool output wrapper\n */\nexport class ToolOutput {\n  readonly value!: string | any;\n\n  constructor(value: string | any) {\n    // Make value truly immutable at runtime\n    Object.defineProperty(this, 'value', {\n      value: value,\n      writable: false,\n      enumerable: true,\n      configurable: false,\n    });\n  }\n}\n\n/**\n * Tool interface for dynamic actions and runtime data fetching\n * Maps to: Tool protocol in Swift FoundationModels\n *\n * Tools enable the model to perform actions like searching, fetching data,\n * or calling APIs. The model determines when a tool is needed, generates\n * appropriate arguments, and the framework handles execution automatically.\n *\n * @example\n * ```typescript\n * class WeatherTool implements Tool {\n *   name = 'getWeather';\n *   description = 'Gets current weather for a location';\n *\n *   async call(args: { city: string }): Promise<ToolOutput> {\n *     const weather = await fetchWeather(args.city);\n *     return new ToolOutput(`Weather in ${args.city}: ${weather}`);\n *   }\n * }\n *\n * const session = new LanguageModelSession({\n *   tools: [new WeatherTool()]\n * });\n * ```\n */\nexport interface Tool {\n  /** Unique identifier for the tool */\n  name: string;\n\n  /** Description of what the tool does (helps model decide when to use it) */\n  description: string;\n\n  /**\n   * Executes the tool with the provided arguments\n   * @param args Structured arguments generated by the model\n   * @returns ToolOutput containing the result\n   */\n  call(args: Record<string, any>): Promise<ToolOutput>;\n}\n\n// ============================================================================\n// Legacy/Compatibility Types\n// ============================================================================\n\n/**\n * Configuration for text generation (legacy)\n */\nexport interface GenerationConfig {\n  /** Maximum number of tokens to generate */\n  maxTokens?: number;\n  /** Temperature for sampling (0.0 to 1.0) */\n  temperature?: number;\n  /** Top-p sampling parameter */\n  topP?: number;\n  /** Stop sequences */\n  stopSequences?: string[];\n}\n\n/**\n * Finish reason for generation (legacy)\n */\nexport enum FinishReason {\n  /** Generation completed naturally */\n  Stop = 'stop',\n  /** Hit maximum token limit */\n  Length = 'length',\n  /** Content filtered */\n  ContentFilter = 'contentFilter',\n  /** Unknown or other reason */\n  Unknown = 'unknown',\n}\n\n/**\n * Result from text generation (legacy)\n */\nexport interface GenerationResult {\n  /** Generated text */\n  text: string;\n  /** Reason why generation finished */\n  finishReason: FinishReason;\n}\n\n/**\n * Role of a message in a conversation (legacy)\n */\nexport enum MessageRole {\n  /** System message that sets the context */\n  System = 'system',\n  /** Message from the user */\n  User = 'user',\n  /** Message from the assistant */\n  Assistant = 'assistant',\n}\n\n/**\n * A message in a conversation (legacy)\n */\nexport interface Message {\n  /** Role of the message sender */\n  role: MessageRole;\n  /** Content of the message */\n  content: string;\n}\n\n/**\n * Configuration for LanguageModelSession (legacy)\n */\nexport interface SessionConfig {\n  /** System prompt to set the context */\n  systemPrompt?: string;\n  /** Default generation configuration for the session */\n  generationConfig?: GenerationConfig;\n}\n\n/**\n * Parameters for generating text (internal)\n */\nexport interface GenerateTextParams {\n  /** The input prompt */\n  prompt: string;\n  /** Optional model ID to use */\n  modelId?: string;\n  /** Maximum tokens to generate */\n  maxTokens?: number;\n  /** Temperature for sampling */\n  temperature?: number;\n}\n\n/**\n * Parameters for streaming text generation (internal)\n */\nexport interface GenerateStreamParams extends GenerateTextParams {\n  /** Callback for each chunk of generated text */\n  onChunk: (chunk: string) => void;\n}\n\n/**\n * Response wrapper from Swift executable (internal)\n */\nexport interface SwiftResponse<T = any> {\n  success: boolean;\n  data?: T;\n  error?: string;\n}\n","import { executeSwiftCommand, executeSwiftStreamCommand } from './executor.js';\nimport type { Executor } from './executor-interface.js';\nimport { ProcessPerCallExecutor } from './executors/process-per-call.js';\nimport { PersistentServerExecutor } from './executors/persistent-server.js';\nimport {\n  type LanguageModelInfo,\n  type GenerationResult,\n  type GenerationConfig,\n  type GenerationOptions,\n  type TranscriptEntry,\n  type Response,\n  type Tool,\n  type ToolCall,\n  Availability,\n  UseCase,\n  Instructions,\n  Guardrails,\n  ToolOutput,\n  FinishReason,\n} from './types.js';\n\n/**\n * SystemLanguageModel - Apple's on-device language model\n * This is a 1-to-1 mapping of the Swift SystemLanguageModel class\n * \n * Usage:\n * ```typescript\n * // Access the default model\n * const model = SystemLanguageModel.default;\n * \n * // Check availability\n * if (model.isAvailable) {\n *   // Create a session and generate\n *   const session = new LanguageModelSession(model);\n *   const response = await session.respond('Hello!');\n * }\n * \n * // Or use a specialized model\n * const taggingModel = new SystemLanguageModel(UseCase.ContentTagging);\n * ```\n */\nexport class SystemLanguageModel {\n  private readonly modelId: string;\n  private readonly useCase?: UseCase;\n  private modelInfo?: LanguageModelInfo;\n  private static _defaultInstance?: SystemLanguageModel;\n\n  /**\n   * The default system language model\n   * Maps to: SystemLanguageModel.default (static property in Swift)\n   */\n  static get default(): SystemLanguageModel {\n    if (!this._defaultInstance) {\n      this._defaultInstance = new SystemLanguageModel('default');\n    }\n    return this._defaultInstance;\n  }\n\n  /**\n   * Get a list of available language models (internal helper)\n   * Note: The actual FoundationModels API only exposes SystemLanguageModel.default\n   * This is kept for internal use only.\n   * @internal\n   */\n  private static get availableModels(): Promise<LanguageModelInfo[]> {\n    return executeSwiftCommand<LanguageModelInfo[]>('listAvailableModels');\n  }\n\n  /**\n   * Create a SystemLanguageModel for a specific use case\n   * Maps to: SystemLanguageModel(useCase:) initializer in Swift\n   * \n   * @param useCase - The specialized use case for the model\n   */\n  constructor(useCase: UseCase);\n  \n  /**\n   * Create a SystemLanguageModel with a specific model ID (internal use)\n   * @param id - The model identifier\n   */\n  constructor(id: string);\n  \n  constructor(idOrUseCase: string | UseCase) {\n    if (typeof idOrUseCase === 'string') {\n      // String ID constructor (internal)\n      this.modelId = idOrUseCase;\n    } else {\n      // UseCase constructor (public API)\n      this.useCase = idOrUseCase;\n      this.modelId = `useCase-${idOrUseCase}`;\n    }\n  }\n\n  /**\n   * Get the model ID\n   */\n  get id(): string {\n    return this.modelId;\n  }\n\n  /**\n   * Get the availability status of the model\n   * Maps to: SystemLanguageModel.availability (instance property in Swift)\n   */\n  get availability(): Availability {\n    // This would need to be implemented to actually check availability\n    // For now, return Available as a placeholder\n    return Availability.Available;\n  }\n\n  /**\n   * Convenience getter to check if the system is entirely ready\n   * Maps to: SystemLanguageModel.isAvailable (instance property in Swift)\n   */\n  get isAvailable(): boolean {\n    return this.availability === Availability.Available;\n  }\n\n  /**\n   * Get the model name (lazy loaded, for internal use)\n   * @internal\n   */\n  async getName(): Promise<string> {\n    await this.ensureModelInfo();\n    return this.modelInfo?.name ?? 'Unknown';\n  }\n\n  /**\n   * Get the maximum tokens for this model (lazy loaded, for internal use)\n   * @internal\n   */\n  async getMaxTokens(): Promise<number> {\n    await this.ensureModelInfo();\n    return this.modelInfo?.maxTokens ?? 0;\n  }\n\n  /**\n   * Generate text using this language model (internal use - prefer LanguageModelSession)\n   * Maps to: SystemLanguageModel.generate(prompt:config:) in Swift\n   * @internal\n   */\n  async generate(prompt: string, config?: GenerationConfig): Promise<GenerationResult> {\n    const result = await executeSwiftCommand<{\n      text: string;\n      finishReason: string;\n    }>('generateText', {\n      prompt,\n      modelId: this.modelId,\n      ...config,\n    });\n    \n    return {\n      text: result.text,\n      finishReason: (result.finishReason as FinishReason) || FinishReason.Unknown,\n    };\n  }\n\n  /**\n   * Generate text with streaming (internal use - prefer LanguageModelSession)\n   * Maps to: SystemLanguageModel streaming functionality in Swift\n   * @internal\n   */\n  async *generateStream(prompt: string, config?: GenerationConfig): AsyncIterableIterator<string> {\n    // Use the stream executor to get chunks\n    for await (const chunk of executeSwiftStreamCommand('generateStream', {\n      prompt,\n      modelId: this.modelId,\n      ...config,\n    })) {\n      yield chunk;\n    }\n  }\n\n  /**\n   * Ensure model info is loaded\n   * @internal\n   */\n  private async ensureModelInfo(): Promise<void> {\n    if (this.modelInfo) {\n      return;\n    }\n\n    const models = await SystemLanguageModel.availableModels;\n    this.modelInfo = models.find(m => m.id === this.modelId);\n    \n    if (!this.modelInfo) {\n      throw new Error(`Model with id '${this.modelId}' not found`);\n    }\n  }\n}\n\n/**\n * LanguageModelSession - Manages stateful interactions with the language model\n * This is a 1-to-1 mapping of the Swift LanguageModelSession class\n * \n * Usage:\n * ```typescript\n * // Create a session with the default model\n * const session = new LanguageModelSession();\n * \n * // With instructions\n * const session = new LanguageModelSession(\n *   SystemLanguageModel.default,\n *   Guardrails.default,\n *   [],\n *   new Instructions('You are a helpful assistant.')\n * );\n * \n * // Send a prompt and get a response\n * const response = await session.respond('Tell me a joke');\n * console.log(response.content);\n * \n * // Stream a response\n * const stream = session.streamResponse('Write a story');\n * for await (const chunk of stream) {\n *   console.log(chunk);\n * }\n * \n * // Access conversation history\n * const history = session.transcript;\n * ```\n */\nexport class LanguageModelSession {\n  private readonly model: SystemLanguageModel;\n  private readonly guardrails: Guardrails;\n  private readonly tools: Tool[];\n  private readonly instructions?: Instructions;\n  private readonly executor: Executor;\n  private transcriptHistory: TranscriptEntry[] = [];\n  private _isResponding: boolean = false;\n\n  /**\n   * Create a new LanguageModelSession\n   *\n   * Maps to multiple Swift initializers:\n   * - init()\n   * - init(instructions:)\n   * - init(model:)\n   * - init(model:instructions:)\n   * - init(model:guardrails:tools:instructions:)\n   *\n   * Note: The actual Swift API does NOT have a separate `guardrails` parameter.\n   * Guardrails are managed internally by the framework.\n   *\n   * IMPORTANT: Tool execution is not yet fully implemented. Tools can be registered\n   * but automatic execution during respond/streamResponse is pending architecture updates.\n   * For now, you must manually handle tool calls from the response transcript.\n   *\n   * @param model - The language model to use (defaults to SystemLanguageModel.default)\n   * @param guardrails - Kept for backwards compatibility, but ignored (guardrails are internal)\n   * @param tools - Array of tools available for the model to call (defaults to [])\n   * @param instructions - Context, role, and preferences for model responses (optional)\n   *\n   * @example\n   * ```typescript\n   * class WeatherTool implements Tool {\n   *   name = 'getWeather';\n   *   description = 'Gets current weather';\n   *   async call(args: { city: string }) {\n   *     return new ToolOutput(`Sunny in ${args.city}`);\n   *   }\n   * }\n   *\n   * const session = new LanguageModelSession(\n   *   SystemLanguageModel.default,\n   *   Guardrails.default,\n   *   [new WeatherTool()],\n   *   new Instructions('You can check weather')\n   * );\n   * ```\n   */\n  constructor(\n    model: SystemLanguageModel = SystemLanguageModel.default,\n    guardrails: Guardrails = Guardrails.default,\n    tools: Tool[] = [],\n    instructions?: Instructions\n  ) {\n    this.model = model;\n    this.guardrails = guardrails;  // Stored but not used (matches actual API behavior)\n    this.tools = tools;\n    this.instructions = instructions;\n\n    // MODAL EXECUTOR SELECTION\n    // - Tools present → PersistentServerExecutor (enables bidirectional communication)\n    // - No tools → ProcessPerCallExecutor (fast path, current behavior)\n    if (tools.length > 0) {\n      this.executor = new PersistentServerExecutor(tools);\n    } else {\n      this.executor = new ProcessPerCallExecutor();\n    }\n\n    // Add instructions to transcript if provided\n    if (this.instructions) {\n      this.transcriptHistory.push({\n        type: 'instructions',\n        instructions: this.instructions,\n      });\n    }\n  }\n\n  /**\n   * Indicates whether the model is currently generating a response\n   * Maps to: LanguageModelSession.isResponding (instance property in Swift)\n   */\n  get isResponding(): boolean {\n    return this._isResponding;\n  }\n\n  /**\n   * Get the conversation transcript\n   * Maps to: LanguageModelSession.transcript (instance property in Swift)\n   */\n  get transcript(): readonly TranscriptEntry[] {\n    return [...this.transcriptHistory];\n  }\n\n  /**\n   * Send a prompt and get a complete response\n   * Maps to: LanguageModelSession.respond(to:) in Swift\n   * \n   * @param prompt - The text prompt to send to the model\n   * @returns Promise resolving to Response containing the model's reply\n   */\n  async respond(prompt: string): Promise<Response<string>>;\n  \n  /**\n   * Send a prompt with custom generation options\n   * Maps to: LanguageModelSession.respond(to:options:) in Swift\n   * \n   * @param prompt - The text prompt to send\n   * @param options - Configuration for generation behavior\n   * @returns Promise resolving to Response containing the model's reply\n   */\n  async respond(prompt: string, options: GenerationOptions): Promise<Response<string>>;\n  \n  async respond(prompt: string, options?: GenerationOptions): Promise<Response<string>> {\n    this._isResponding = true;\n\n    try {\n      // Add prompt to transcript\n      this.transcriptHistory.push({\n        type: 'prompt',\n        content: prompt,\n      });\n\n      // Build context from transcript\n      const contextPrompt = this.buildContextPrompt();\n\n      // Execute via selected executor (modal: ProcessPerCall or PersistentServer)\n      const data = await this.executor.execute<{ text?: string; content?: string }>('generateText', {\n        prompt: contextPrompt,\n        maxTokens: options?.maximumResponseTokens,\n        temperature: options?.temperature,\n        sampling: options?.sampling,\n      });\n\n      // Swift wrapper returns 'text', but accept 'content' for backward compatibility\n      const responseText = data.text || data.content || '';\n\n      // Add response to transcript\n      this.transcriptHistory.push({\n        type: 'response',\n        content: responseText,\n      });\n\n      return {\n        content: responseText,\n        transcriptEntries: [...this.transcriptHistory],\n      };\n    } finally {\n      this._isResponding = false;\n    }\n  }\n\n  /**\n   * Stream the model's response incrementally\n   * Maps to: LanguageModelSession.streamResponse(to:) in Swift\n   *\n   * @param prompt - The text prompt to send\n   * @returns AsyncIterable that yields text chunks\n   */\n  async *streamResponse(prompt: string): AsyncIterableIterator<string> {\n    this._isResponding = true;\n\n    try {\n      // Add prompt to transcript\n      this.transcriptHistory.push({\n        type: 'prompt',\n        content: prompt,\n      });\n\n      // Build context from transcript\n      const contextPrompt = this.buildContextPrompt();\n\n      // Stream via selected executor (modal: ProcessPerCall or PersistentServer)\n      let fullResponse = '';\n      for await (const chunk of this.executor.executeStream('generateStream', { prompt: contextPrompt })) {\n        fullResponse += chunk;\n        yield chunk;\n      }\n\n      // Add complete response to transcript\n      this.transcriptHistory.push({\n        type: 'response',\n        content: fullResponse,\n      });\n    } finally {\n      this._isResponding = false;\n    }\n  }\n\n  /**\n   * Preload session resources for faster initial responses\n   * Maps to: LanguageModelSession.prewarm() in Swift\n   *\n   * Prewarming initializes the model and allocates resources ahead of time,\n   * reducing latency for the first generation request. This is especially useful\n   * when you know you'll need the model soon but want to minimize wait time.\n   *\n   * @example\n   * ```typescript\n   * const session = new LanguageModelSession();\n   * await session.prewarm(); // Initialize resources\n   * // First generation will be faster\n   * const response = await session.respond('Hello');\n   * ```\n   */\n  async prewarm(): Promise<void> {\n    await executeSwiftCommand('prewarm', {});\n  }\n\n  /**\n   * Preload session with a prompt prefix for optimized generation\n   * Maps to: LanguageModelSession.prewarm(promptPrefix:) in Swift\n   *\n   * Prewarming with a prefix allows the model to process and cache the prefix,\n   * which can significantly speed up generation when using that prefix. This is\n   * particularly useful for system prompts that will be reused or template-based generation.\n   *\n   * @param promptPrefix - The prompt prefix to preload\n   * @example\n   * ```typescript\n   * const session = new LanguageModelSession();\n   * await session.prewarmWithPrefix('You are a helpful coding assistant.');\n   * // Subsequent generations with this prefix will be faster\n   * const response = await session.respond('that specializes in TypeScript...');\n   * ```\n   */\n  async prewarmWithPrefix(promptPrefix: string): Promise<void> {\n    await executeSwiftCommand('prewarmWithPrefix', { prefix: promptPrefix });\n  }\n\n  /**\n   * Close the session and clean up resources\n   *\n   * **API DEVIATION**: This method does not exist in the Swift FoundationModels API,\n   * where resource cleanup is automatic via ARC (Automatic Reference Counting).\n   * In JavaScript, we need explicit cleanup for:\n   * - Persistent server processes (when using tools)\n   * - Unix socket connections\n   * - Background threads\n   *\n   * **When to call**:\n   * - Required: When session has tools (uses persistent server)\n   * - Optional: When session has no tools (process-per-call, no cleanup needed)\n   *\n   * **Best Practice**: Always call close() in a finally block or use try-finally pattern.\n   *\n   * @example\n   * ```typescript\n   * // With tools (persistent server - cleanup required)\n   * const session = new LanguageModelSession(model, undefined, [weatherTool]);\n   * try {\n   *   await session.respond('What\\'s the weather?');\n   * } finally {\n   *   await session.close();  // Shuts down server, removes socket\n   * }\n   *\n   * // Without tools (process-per-call - cleanup optional but harmless)\n   * const simpleSession = new LanguageModelSession();\n   * try {\n   *   await simpleSession.respond('Hello');\n   * } finally {\n   *   await simpleSession.close();  // No-op, but good practice\n   * }\n   * ```\n   */\n  async close(): Promise<void> {\n    await this.executor.close();\n  }\n\n  /**\n   * Build a context prompt from transcript history\n   * @internal\n   */\n  private buildContextPrompt(): string {\n    return this.transcriptHistory\n      .map(entry => {\n        switch (entry.type) {\n          case 'instructions':\n            return `Instructions: ${entry.instructions.text}`;\n          case 'prompt':\n            return `User: ${entry.content}`;\n          case 'response':\n            return `Assistant: ${entry.content}`;\n          case 'toolCalls':\n            return `Tools called: ${entry.calls.length}`;\n          case 'toolOutput':\n            return `Tool output: ${JSON.stringify(entry.output)}`;\n          default:\n            return '';\n        }\n      })\n      .filter(Boolean)\n      .join('\\n\\n');\n  }\n}\n"],"mappings":"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"}