@eclipse-lyra/extension-ai-system 0.0.0

package/dist/ai-service-CGdlV3FV.js

@@ -0,0 +1,1731 @@
+import { contributionRegistry, createLogger, commandRegistry, appSettings, publish, persistenceService, subscribe, TOPIC_SETTINGS_CHANGED, logger as logger$1, rootContext } from "@eclipse-lyra/core";
+const TOPIC_AI_STREAM_STARTED = "events/aiservice/streamStarted";
+const TOPIC_AI_STREAM_CHUNK = "events/aiservice/streamChunk";
+const TOPIC_AI_STREAM_COMPLETE = "events/aiservice/streamComplete";
+const TOPIC_AI_STREAM_ERROR = "events/aiservice/streamError";
+const TOPIC_AICONFIG_CHANGED = "events/aiservice/aiConfigChanged";
+const TOPIC_AGENT_WORKFLOW_STARTED = "events/aiservice/agentWorkflowStarted";
+const TOPIC_AGENT_WORKFLOW_COMPLETE = "events/aiservice/agentWorkflowComplete";
+const TOPIC_AGENT_WORKFLOW_ERROR = "events/aiservice/agentWorkflowError";
+const CID_AGENTS = "aiservice.agents";
+const CID_CHAT_PROVIDERS = "aiservice.chatProviders";
+const CID_PROMPT_ENHANCERS = "aiservice.promptEnhancers";
+const KEY_AI_CONFIG = "aiConfig";
+const DEFAULT_AGENT_ROLE = "appsupport";
+const AI_CONFIG_TEMPLATE = {
+  "defaultProvider": "openai",
+  "providers": [],
+  "requireToolApproval": true
+};
+const MAX_TOOL_ITERATIONS = 10;
+const MAX_RECENT_TOOL_CALLS = 5;
+class StreamParser {
+  constructor() {
+    this.decoder = new TextDecoder();
+    this.usage = null;
+  }
+  async *readLines(reader) {
+    let buffer = "";
+    this.usage = null;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += this.decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.trim()) yield* this.processLine(line);
+        }
+      }
+      if (buffer.trim()) yield* this.processLine(buffer);
+      yield this.makeDoneChunk();
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  makeDoneChunk() {
+    const chunk = { type: "done", content: "" };
+    if (this.usage) chunk.metadata = { usage: this.usage };
+    return chunk;
+  }
+}
+class SSEParser extends StreamParser {
+  async *parse(reader) {
+    yield* this.readLines(reader);
+  }
+  async *processLine(line) {
+    if (!line.startsWith("data: ")) return;
+    const data = line.slice(6).trim();
+    if (data === "[DONE]") {
+      yield this.makeDoneChunk();
+      return;
+    }
+    try {
+      const json = JSON.parse(data);
+      if (json.error) {
+        yield { type: "error", content: json.error.message || "Unknown error", metadata: json.error };
+        return;
+      }
+      this.extractUsage(json);
+      const chunk = this.parseChunk(json);
+      if (chunk) yield chunk;
+    } catch {
+    }
+  }
+  extractUsage(json) {
+    if (!json.usage) return;
+    const u = json.usage;
+    this.usage = {
+      promptTokens: u.prompt_tokens || 0,
+      completionTokens: u.completion_tokens || 0,
+      totalTokens: u.total_tokens || 0,
+      estimated: false
+    };
+  }
+  parseChunk(json) {
+    const delta = json.choices?.[0]?.delta;
+    const choice = json.choices?.[0];
+    if (delta?.content) {
+      return {
+        type: "token",
+        content: delta.content,
+        message: { role: delta.role || "assistant", content: choice?.message?.content || delta.content }
+      };
+    }
+    if (choice?.message?.tool_calls) {
+      const toolCalls = this.parseToolCalls(choice.message.tool_calls, true);
+      if (toolCalls.length > 0) return { type: "token", content: "", toolCalls };
+    } else if (delta?.tool_calls || choice?.delta?.tool_calls) {
+      const toolCalls = this.parseToolCalls(delta?.tool_calls || choice?.delta?.tool_calls || [], false);
+      if (toolCalls.length > 0) return { type: "token", content: "", toolCalls };
+    }
+    return null;
+  }
+  parseToolCalls(toolCalls, isComplete) {
+    return toolCalls.filter((tc) => tc.function !== void 0).map((tc, idx) => ({
+      id: tc.id || `call_${tc.index !== void 0 ? tc.index : idx}_${Date.now()}`,
+      type: "function",
+      function: {
+        name: tc.function?.name || "",
+        arguments: tc.function?.arguments || (isComplete ? "{}" : "")
+      },
+      _index: tc.index !== void 0 ? tc.index : idx
+    }));
+  }
+}
+class OllamaParser extends StreamParser {
+  async *parse(reader) {
+    yield* this.readLines(reader);
+  }
+  async *processLine(line) {
+    try {
+      const json = JSON.parse(line);
+      if (json.error) {
+        yield { type: "error", content: json.error, metadata: json };
+        return;
+      }
+      if (json.done) {
+        this.extractUsage(json);
+        yield this.makeDoneChunk();
+        return;
+      }
+      const tokenChunk = this.parseToken(json);
+      if (tokenChunk) yield tokenChunk;
+    } catch {
+    }
+  }
+  extractUsage(json) {
+    if (json.prompt_eval_count === void 0 && json.eval_count === void 0) return;
+    const promptTokens = json.prompt_eval_count || 0;
+    const completionTokens = json.eval_count || 0;
+    this.usage = { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens, estimated: false };
+  }
+  parseToken(json) {
+    if (json.message?.content) {
+      return { type: "token", content: json.message.content, message: { role: json.message.role || "assistant", content: json.message.content } };
+    }
+    if (json.response) {
+      return { type: "token", content: json.response, message: { role: "assistant", content: json.response } };
+    }
+    return null;
+  }
+}
+async function streamToText(messages, chatConfig, providerFactory) {
+  let content = "";
+  const provider = providerFactory.getProvider(chatConfig);
+  for await (const chunk of provider.stream({ model: chatConfig.model, messages, chatConfig })) {
+    if (chunk.type === "token") content += chunk.content;
+  }
+  return content;
+}
+function extractBaseUrl(endpoint) {
+  if (!endpoint) return null;
+  if (endpoint.includes("/v1/chat/completions")) {
+    return endpoint.replace("/v1/chat/completions", "");
+  }
+  if (endpoint.includes("/api/v1/chat/completions")) {
+    return endpoint.replace("/api/v1/chat/completions", "");
+  }
+  if (endpoint.includes("/api/chat/completion")) {
+    return endpoint.replace("/api/chat/completion", "");
+  }
+  try {
+    const url = new URL(endpoint);
+    return `${url.protocol}//${url.host}`;
+  } catch {
+    return null;
+  }
+}
+class BaseProvider {
+  createParser(contentType, endpoint) {
+    if (contentType.includes("text/event-stream") || endpoint.includes("openai")) {
+      return new SSEParser();
+    }
+    return new OllamaParser();
+  }
+  async getAvailableModels(chatProvider) {
+    if (!chatProvider.chatApiEndpoint) return [];
+    const baseUrl = extractBaseUrl(chatProvider.chatApiEndpoint);
+    if (!baseUrl) return [];
+    try {
+      const headers = { "Content-Type": "application/json" };
+      if (chatProvider.apiKey) {
+        headers["Authorization"] = `Bearer ${chatProvider.apiKey}`;
+      }
+      const response = await fetch(`${baseUrl}/v1/models`, { method: "GET", headers });
+      if (!response.ok) return [];
+      const data = await response.json();
+      return (data.data || []).map((m) => ({ id: m.id, name: m.name || m.id }));
+    } catch {
+      return [];
+    }
+  }
+  async *stream(params) {
+    const requestBody = {
+      model: params.model,
+      stream: true,
+      messages: params.messages,
+      ...params.chatConfig.parameters
+    };
+    if (params.tools && params.tools.length > 0) {
+      requestBody.tools = params.tools;
+      requestBody.tool_choice = "auto";
+    }
+    const response = await fetch(params.chatConfig.chatApiEndpoint, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${params.chatConfig.apiKey}`,
+        "Content-Type": "application/json",
+        "Accept": "text/event-stream"
+      },
+      body: JSON.stringify(requestBody),
+      signal: params.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      yield { type: "error", content: `HTTP ${response.status}: ${errorText}`, metadata: { status: response.status } };
+      return;
+    }
+    if (!response.body) {
+      yield { type: "error", content: "Response body is null or empty", metadata: { status: response.status } };
+      return;
+    }
+    const reader = response.body.getReader();
+    if (!reader) {
+      yield { type: "error", content: "Response body is not readable" };
+      return;
+    }
+    const contentType = response.headers.get("content-type") || "";
+    const parser = this.createParser(contentType, params.chatConfig.chatApiEndpoint);
+    try {
+      for await (const chunk of parser.parse(reader)) {
+        yield chunk;
+      }
+    } catch (error) {
+      yield {
+        type: "error",
+        content: error instanceof Error ? error.message : "Failed to parse response stream",
+        metadata: { error, contentType }
+      };
+    }
+  }
+}
+class OpenAIProvider extends BaseProvider {
+  constructor() {
+    super(...arguments);
+    this.name = "openai";
+  }
+  canHandle(chatProvider) {
+    return chatProvider.chatApiEndpoint.includes("openai") || chatProvider.chatApiEndpoint.includes("v1/chat/completions");
+  }
+}
+class OllamaProvider extends BaseProvider {
+  constructor() {
+    super(...arguments);
+    this.name = "ollama";
+  }
+  canHandle(chatProvider) {
+    return chatProvider.name.toLowerCase() === "ollama" || chatProvider.chatApiEndpoint.includes("ollama") || chatProvider.chatApiEndpoint.includes("localhost:11434");
+  }
+}
+class ProviderFactory {
+  constructor() {
+    this.providers = [];
+    this.providers.push(new OpenAIProvider());
+    this.providers.push(new OllamaProvider());
+  }
+  registerProvider(provider) {
+    this.providers.push(provider);
+  }
+  getProvider(chatProvider) {
+    return this.providers.find((p) => p.canHandle(chatProvider)) ?? this.providers[0];
+  }
+  getAllProviders() {
+    return [...this.providers];
+  }
+}
+class AgentRegistry {
+  getAgentContributions() {
+    return contributionRegistry.getContributions(CID_AGENTS);
+  }
+  filterAndSortAgents(contributions, context) {
+    return contributions.filter((c) => !c.canHandle || c.canHandle(context)).sort((a, b) => (b.priority || 0) - (a.priority || 0));
+  }
+  getMatchingAgents(context, roles) {
+    const contributions = this.getAgentContributions();
+    if (contributions.length === 0) {
+      throw new Error("No agents are registered. The App Support agent should be available from the AI system extension.");
+    }
+    const roleFiltered = roles?.length ? contributions.filter((c) => roles.includes(c.role)) : contributions;
+    const active = this.filterAndSortAgents(roleFiltered, context);
+    if (roles?.length && active.length === 0) {
+      throw new Error(`No agents found for requested roles: ${roles.join(", ")}. Available: ${contributions.map((c) => c.role).join(", ")}`);
+    }
+    if (!roles?.length && active.length === 0) {
+      throw new Error(`No agents can handle the current context. Available: ${contributions.map((c) => c.role).join(", ")}`);
+    }
+    return active;
+  }
+}
+function sanitizeMessageForAPI(message) {
+  const apiMessage = {
+    role: message.role,
+    content: message.content
+  };
+  if ("tool_call_id" in message && message.tool_call_id) {
+    apiMessage.tool_call_id = message.tool_call_id;
+  }
+  if ("tool_calls" in message && message.tool_calls) {
+    apiMessage.tool_calls = message.tool_calls;
+  }
+  return apiMessage;
+}
+function sanitizeMessagesForAPI(messages) {
+  return messages.map(sanitizeMessageForAPI);
+}
+const logger = createLogger("ToolDetector");
+const GREETINGS = ["hello", "hi", "hey", "thanks", "thank you", "bye", "goodbye"];
+const ACTION_KEYWORDS = [
+  "create",
+  "open",
+  "delete",
+  "read",
+  "write",
+  "edit",
+  "save",
+  "rename",
+  "move",
+  "copy",
+  "list",
+  "show",
+  "display",
+  "run",
+  "execute",
+  "build",
+  "add",
+  "remove",
+  "update",
+  "modify",
+  "change",
+  "set",
+  "get",
+  "find",
+  "search",
+  "filter",
+  "sort",
+  "install",
+  "uninstall",
+  "load",
+  "import",
+  "export",
+  "generate",
+  "make",
+  "do",
+  "perform",
+  "call",
+  "invoke"
+];
+const CONTEXT_KEYWORDS = [
+  "file",
+  "folder",
+  "directory",
+  "workspace",
+  "editor",
+  "map",
+  "layer",
+  "command",
+  "tool",
+  "extension",
+  "script",
+  "code",
+  "project"
+];
+class ToolDetector {
+  needsTools(prompt) {
+    if (!prompt?.trim()) return false;
+    const normalized = prompt.toLowerCase().trim();
+    if (GREETINGS.some((g) => normalized === g || normalized.startsWith(g + " "))) return false;
+    const hasAction = ACTION_KEYWORDS.some((k) => prompt.includes(k));
+    const hasContext = CONTEXT_KEYWORDS.some((k) => prompt.includes(k));
+    const needsTools = hasAction && (hasContext || prompt.length > 20);
+    if (needsTools) logger.info(`Heuristic: needsTools=true (action+context or long prompt)`);
+    return needsTools;
+  }
+  dispose() {
+  }
+}
+const toolDetector = new ToolDetector();
+class PromptBuilder {
+  constructor(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+    this.enhancers = [];
+  }
+  addEnhancer(enhancer) {
+    this.enhancers.push(enhancer);
+  }
+  async getSysPrompt(contribution, context) {
+    let sysPrompt = contribution.sysPrompt;
+    if (typeof sysPrompt === "function") sysPrompt = sysPrompt();
+    if (!sysPrompt || typeof sysPrompt !== "string") {
+      throw new Error(`Agent "${contribution.role}" is missing a system prompt.`);
+    }
+    const allEnhancers = [
+      ...contribution.promptEnhancers || [],
+      ...this.enhancers,
+      ...this.getContributedEnhancers()
+    ].sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    let enhanced = sysPrompt;
+    for (const enhancer of allEnhancers) {
+      try {
+        const result = await enhancer.enhance(enhanced, context);
+        if (result && typeof result === "string") enhanced = result;
+      } catch (err) {
+        console.warn("[PromptBuilder] Enhancer failed:", err);
+      }
+    }
+    return enhanced;
+  }
+  rewriteChatHistoryForAgent(history, targetRole) {
+    return history.map((m) => {
+      if (m.role === "user") return { role: m.role, content: m.content };
+      if (m.role === targetRole) return { role: "assistant", content: m.content };
+      return { role: "user", content: `***Agent '${m.role}' replied:***
+${m.content}` };
+    });
+  }
+  getContributedEnhancers() {
+    const contributions = contributionRegistry.getContributions(CID_PROMPT_ENHANCERS);
+    return contributions.map((c) => ({ ...c.enhancer, priority: c.priority ?? c.enhancer.priority }));
+  }
+  async build(contribution, messages, context, hooks) {
+    if (hooks?.beforeSend) await hooks.beforeSend(messages, context);
+    const sanitized = sanitizeMessagesForAPI(messages);
+    const rewritten = this.rewriteChatHistoryForAgent(sanitized, contribution.role);
+    let toolsConfig = contribution.tools;
+    if (typeof toolsConfig === "function") toolsConfig = await toolsConfig();
+    let tools;
+    if (toolsConfig?.enabled) {
+      if (toolsConfig.smartToolDetection) {
+        const lastUser = messages[messages.length - 1];
+        if (toolDetector.needsTools(lastUser?.content || "")) {
+          tools = this.toolRegistry.getAvailableTools(context, toolsConfig.commandFilter);
+        }
+      } else {
+        tools = this.toolRegistry.getAvailableTools(context, toolsConfig.commandFilter);
+      }
+    }
+    const sysPrompt = await this.getSysPrompt(contribution, context);
+    rewritten.unshift({ role: "system", content: sysPrompt });
+    return { messages: rewritten, userPromptIndex: rewritten.length - 1, tools };
+  }
+}
+class MessageProcessorService {
+  constructor() {
+    this.processors = [];
+  }
+  addProcessor(processor) {
+    this.processors.push(processor);
+  }
+  async process(message, contribution, context) {
+    const allProcessors = [
+      ...contribution.messageProcessors || [],
+      ...this.processors
+    ].sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    let processed = { ...message };
+    for (const processor of allProcessors) {
+      processed = await processor.process(processed, context);
+    }
+    return processed;
+  }
+}
+class ToolCallAccumulator {
+  constructor() {
+    this.accumulatedToolCalls = /* @__PURE__ */ new Map();
+    this.toolCallIndexMap = /* @__PURE__ */ new Map();
+  }
+  processChunk(chunk) {
+    if (chunk.type !== "token" || !chunk.toolCalls?.length) return;
+    for (const toolCall of chunk.toolCalls) {
+      const callIndex = toolCall._index;
+      const callId = toolCall.id;
+      let existing;
+      let targetId;
+      if (callIndex !== void 0 && this.toolCallIndexMap.has(callIndex)) {
+        targetId = this.toolCallIndexMap.get(callIndex);
+        existing = this.accumulatedToolCalls.get(targetId);
+      } else if (callId && this.accumulatedToolCalls.has(callId)) {
+        targetId = callId;
+        existing = this.accumulatedToolCalls.get(targetId);
+      } else {
+        targetId = callId || `call_${callIndex !== void 0 ? callIndex : Date.now()}_${Math.random()}`;
+        existing = void 0;
+      }
+      if (existing) {
+        this.accumulatedToolCalls.set(targetId, {
+          id: targetId,
+          type: toolCall.type || existing.type,
+          function: {
+            name: toolCall.function.name || existing.function.name,
+            arguments: (existing.function.arguments || "") + (toolCall.function.arguments || "")
+          }
+        });
+        if (callIndex !== void 0 && !this.toolCallIndexMap.has(callIndex)) {
+          this.toolCallIndexMap.set(callIndex, targetId);
+        }
+      } else {
+        this.accumulatedToolCalls.set(targetId, { ...toolCall, id: targetId });
+        if (callIndex !== void 0) {
+          this.toolCallIndexMap.set(callIndex, targetId);
+        }
+      }
+    }
+  }
+  getFinalToolCalls() {
+    return Array.from(this.accumulatedToolCalls.values()).filter((tc) => tc.function.name?.trim().length > 0).map((tc) => ({
+      ...tc,
+      function: { ...tc.function, arguments: tc.function.arguments?.trim() || "{}" }
+    }));
+  }
+  reset() {
+    this.accumulatedToolCalls.clear();
+    this.toolCallIndexMap.clear();
+  }
+}
+function sanitizeFunctionName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^[^a-zA-Z]/, "cmd_$&").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+class ToolExecutor {
+  findCommand(toolCall, context) {
+    const sanitizedName = toolCall.function.name;
+    const direct = commandRegistry.getCommand(sanitizedName);
+    if (direct) return direct;
+    const allCommands = commandRegistry.listCommands();
+    for (const [commandId, command] of Object.entries(allCommands)) {
+      if (sanitizeFunctionName(commandId) === sanitizedName) {
+        return command;
+      }
+    }
+    return null;
+  }
+  parseArguments(argsStr) {
+    if (!argsStr?.trim() || argsStr === "{}") return {};
+    try {
+      const parsed = JSON.parse(argsStr);
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  sanitizeArguments(args, command) {
+    if (!command?.parameters || !args || typeof args !== "object") return args || {};
+    const sanitizedArgs = {};
+    command.parameters.forEach((param) => {
+      const sanitizedParamName = sanitizeFunctionName(param.name);
+      if (sanitizedParamName in args) {
+        sanitizedArgs[param.name] = args[sanitizedParamName];
+      }
+    });
+    return sanitizedArgs;
+  }
+  async executeToolCall(toolCall, context) {
+    try {
+      const command = this.findCommand(toolCall, context);
+      const commandId = command?.id || toolCall.function.name;
+      const args = this.parseArguments(toolCall.function.arguments || "{}");
+      const sanitizedArgs = this.sanitizeArguments(args, command);
+      const freshContext = commandRegistry.createExecutionContext(sanitizedArgs);
+      const execContext = { ...context, ...freshContext, params: sanitizedArgs };
+      const commandResult = await commandRegistry.execute(commandId, execContext);
+      const commandName = command?.name || commandId;
+      const resultMessage = {
+        success: true,
+        message: `Command "${commandName}" executed successfully`,
+        command: commandId
+      };
+      if (Object.keys(sanitizedArgs).length > 0) {
+        resultMessage.parameters = sanitizedArgs;
+      }
+      if (commandResult != null) {
+        let resolved = commandResult;
+        if (resolved instanceof Promise) resolved = await resolved;
+        resultMessage.result = resolved;
+        if (command?.output?.length) {
+          resultMessage.output = command.output.map((v) => `${v.name}: ${v.description || v.type || "value"}`).join(", ");
+        }
+      }
+      return { id: toolCall.id, result: resultMessage };
+    } catch (error) {
+      let command = null;
+      try {
+        command = this.findCommand(toolCall, context);
+      } catch {
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const commandName = command?.name || toolCall.function.name;
+      let detailedError = errorMessage;
+      if (errorMessage.includes("No handler found") || errorMessage.includes("No handlers registered")) {
+        detailedError = `Command "${commandName}" cannot be executed. ${errorMessage}.`;
+      }
+      return { id: toolCall.id, result: null, error: detailedError };
+    }
+  }
+  async executeToolCalls(toolCalls, context) {
+    const results = [];
+    for (const toolCall of toolCalls) {
+      results.push(await this.executeToolCall(toolCall, context));
+    }
+    return results;
+  }
+  createToolCallAccumulator() {
+    return new ToolCallAccumulator();
+  }
+  createToolCallSignature(toolCall) {
+    let args = {};
+    try {
+      const parsed = JSON.parse(toolCall.function.arguments || "{}");
+      args = parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      args = {};
+    }
+    const sortedArgs = Object.keys(args).sort().reduce((acc, key) => {
+      acc[key] = args[key];
+      return acc;
+    }, {});
+    return `${toolCall.function.name}:${JSON.stringify(sortedArgs)}`;
+  }
+}
+class ToolRegistry {
+  commandToTool(command, context) {
+    const properties = {};
+    const required = [];
+    command.parameters?.forEach((param) => {
+      const sanitizedParamName = sanitizeFunctionName(param.name);
+      properties[sanitizedParamName] = {
+        type: param.type || "string",
+        description: param.description,
+        ...param.allowedValues && { enum: param.allowedValues }
+      };
+      if (param.required === true) {
+        required.push(sanitizedParamName);
+      }
+    });
+    return {
+      type: "function",
+      function: {
+        name: sanitizeFunctionName(command.id),
+        description: command.description || command.name,
+        parameters: { type: "object", properties, required }
+      }
+    };
+  }
+  getAvailableTools(context, commandFilter) {
+    const availableCommands = commandRegistry.listCommands();
+    let commandsArray = Object.values(availableCommands);
+    if (commandFilter) {
+      commandsArray = commandsArray.filter((cmd) => commandFilter(cmd, context));
+    }
+    return commandsArray.map((cmd) => this.commandToTool(cmd, context));
+  }
+}
+class ParallelWorkflowStrategy {
+  async execute(contributions, options, results, executeAgent) {
+    const chatConfig = options.chatConfig;
+    if (!chatConfig) throw new Error("Chat config is required");
+    await Promise.all(contributions.map(async (contrib) => {
+      try {
+        await executeAgent(contrib, options.chatContext.history, results.sharedState, chatConfig, options, results);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        results.errors.set(contrib.role, err);
+        options.onAgentError?.(contrib.role, err);
+      }
+    }));
+  }
+}
+class BaseSequentialWorkflow {
+  createAgentContextWithPreviousAgents(accumulatedState, options, results) {
+    return {
+      ...accumulatedState,
+      ...options.callContext.getProxy(),
+      previousAgents: Array.from(results.messages.entries()).map(([role, msg]) => ({
+        role,
+        content: msg.content
+      }))
+    };
+  }
+  updateWorkflowState(finalMessage, currentMessages, accumulatedState, agentContext, results) {
+    currentMessages.push(finalMessage);
+    accumulatedState = { ...accumulatedState, ...agentContext, message: finalMessage };
+    results.sharedState = accumulatedState;
+    return { currentMessages, accumulatedState };
+  }
+}
+class SequentialWorkflowStrategy extends BaseSequentialWorkflow {
+  async execute(contributions, options, results, executeAgent) {
+    const chatConfig = options.chatConfig;
+    if (!chatConfig) throw new Error("Chat config is required");
+    let currentMessages = [...options.chatContext.history];
+    let accumulatedState = { ...results.sharedState };
+    for (const contrib of contributions) {
+      try {
+        const agentContext = this.createAgentContextWithPreviousAgents(accumulatedState, options, results);
+        const finalMessage = await executeAgent(contrib, currentMessages, accumulatedState, chatConfig, options, results);
+        if (!finalMessage) break;
+        const updated = this.updateWorkflowState(finalMessage, currentMessages, accumulatedState, agentContext, results);
+        currentMessages = updated.currentMessages;
+        accumulatedState = updated.accumulatedState;
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        results.errors.set(contrib.role, err);
+        options.onAgentError?.(contrib.role, err);
+        break;
+      }
+    }
+  }
+}
+class ConditionalWorkflowStrategy extends BaseSequentialWorkflow {
+  async execute(contributions, options, results, executeAgent) {
+    const chatConfig = options.chatConfig;
+    if (!chatConfig) throw new Error("Chat config is required");
+    let currentMessages = [...options.chatContext.history];
+    let accumulatedState = { ...results.sharedState };
+    for (const contrib of contributions) {
+      try {
+        const agentContext = this.createAgentContextWithPreviousAgents(accumulatedState, options, results);
+        if (contrib.canHandle && !contrib.canHandle(agentContext)) continue;
+        const finalMessage = await executeAgent(contrib, currentMessages, accumulatedState, chatConfig, options, results);
+        if (!finalMessage) break;
+        const updated = this.updateWorkflowState(finalMessage, currentMessages, accumulatedState, agentContext, results);
+        currentMessages = updated.currentMessages;
+        accumulatedState = updated.accumulatedState;
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        results.errors.set(contrib.role, err);
+        options.onAgentError?.(contrib.role, err);
+      }
+    }
+  }
+}
+class PipelineWorkflowStrategy {
+  async execute(contributions, options, results, executeAgent) {
+    const chatConfig = options.chatConfig;
+    if (!chatConfig) throw new Error("Chat config is required");
+    let currentMessages = [...options.chatContext.history];
+    for (const wave of this.buildTopoOrder(contributions)) {
+      await Promise.all(wave.map(async (contrib) => {
+        try {
+          await executeAgent(contrib, currentMessages, results.sharedState, chatConfig, options, results);
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          results.errors.set(contrib.role, err);
+          options.onAgentError?.(contrib.role, err);
+        }
+      }));
+      for (const contrib of wave) {
+        const msg = results.messages.get(contrib.role);
+        if (msg) currentMessages.push(msg);
+      }
+    }
+  }
+  buildTopoOrder(contributions) {
+    const waves = [];
+    const placed = /* @__PURE__ */ new Set();
+    while (placed.size < contributions.length) {
+      const wave = contributions.filter((c) => {
+        if (placed.has(c.role)) return false;
+        if (!c.consumes?.length) return true;
+        const allProduced = contributions.filter((other) => placed.has(other.role)).flatMap((other) => other.produces || []);
+        return c.consumes.every((t) => allProduced.includes(t));
+      });
+      if (wave.length === 0) {
+        waves.push(contributions.filter((c) => !placed.has(c.role)));
+        break;
+      }
+      waves.push(wave);
+      for (const c of wave) placed.add(c.role);
+    }
+    return waves;
+  }
+}
+function createTaskPlan(originalPrompt, steps) {
+  const now = Date.now();
+  return {
+    id: `plan-${now}-${Math.random().toString(36).slice(2, 9)}`,
+    originalPrompt,
+    steps: steps.map((s) => ({ ...s, status: "pending", revisions: 0 })),
+    status: "planning",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function getNextRunnableSteps(plan) {
+  const completed = new Set(plan.steps.filter((s) => s.status === "completed").map((s) => s.id));
+  return plan.steps.filter((s) => s.status === "pending" && s.dependsOn.every((d) => completed.has(d)));
+}
+function isPlanComplete(plan) {
+  return plan.steps.every((s) => s.status === "completed" || s.status === "skipped");
+}
+function isPlanFailed(plan) {
+  return plan.steps.some((s) => s.status === "failed");
+}
+const ORCHESTRATOR_SYS_PROMPT = `You are a task orchestrator. Given a user's complex request, decompose it into a structured execution plan.
+
+Respond with ONLY a JSON object matching this schema (no markdown, no explanation):
+{
+  "steps": [
+    {
+      "id": "step-1",
+      "role": "<agent role>",
+      "subTask": "<specific instruction for this step>",
+      "dependsOn": [],
+      "consumes": [],
+      "produces": ["<artifact-id>"]
+    }
+  ]
+}
+
+Rules:
+- Each step must have a unique id (step-1, step-2, ...)
+- "role" must match an available agent role
+- "dependsOn" lists step IDs that must complete before this step
+- "consumes" and "produces" are artifact IDs
+- Steps with no dependencies can run in parallel
+- Keep the plan minimal — only as many steps as needed`;
+async function orchestrateTask(options) {
+  const agentList = options.availableAgents.filter((a) => !a.isOrchestrator).map((a) => `- ${a.role}: ${a.description}`).join("\n");
+  const messages = [
+    { role: "system", content: `${ORCHESTRATOR_SYS_PROMPT}
+
+Available agents:
+${agentList}` },
+    { role: "user", content: options.prompt }
+  ];
+  const responseText = await options.executeCompletion(messages, options.chatConfig);
+  try {
+    const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) throw new Error("No JSON found in orchestrator response");
+    const parsed = JSON.parse(jsonMatch[0]);
+    return createTaskPlan(options.prompt, parsed.steps || []);
+  } catch (error) {
+    const defaultAgent = options.availableAgents.find((a) => !a.isOrchestrator);
+    return createTaskPlan(options.prompt, [{
+      id: "step-1",
+      role: defaultAgent?.role || DEFAULT_AGENT_ROLE,
+      subTask: options.prompt,
+      dependsOn: [],
+      consumes: [],
+      produces: ["step-1-result"]
+    }]);
+  }
+}
+class TaskWorkspace {
+  constructor(taskId, plan) {
+    this.artifacts = /* @__PURE__ */ new Map();
+    this.mailbox = /* @__PURE__ */ new Map();
+    this.taskId = taskId;
+    this.plan = plan;
+  }
+  putArtifact(artifact) {
+    this.artifacts.set(artifact.id, artifact);
+  }
+  getArtifact(id) {
+    return this.artifacts.get(id);
+  }
+  getArtifactsByType(type) {
+    return Array.from(this.artifacts.values()).filter((a) => a.type === type);
+  }
+  getArtifactsProducedBy(role) {
+    return Array.from(this.artifacts.values()).filter((a) => a.producedBy === role);
+  }
+  postMessage(message) {
+    const key = message.to === "*" ? "__broadcast__" : message.to;
+    const messages = this.mailbox.get(key) || [];
+    messages.push(message);
+    this.mailbox.set(key, messages);
+  }
+  readMessages(recipientRole) {
+    const direct = this.mailbox.get(recipientRole) || [];
+    const broadcast = this.mailbox.get("__broadcast__") || [];
+    return [...direct, ...broadcast];
+  }
+  clearMessages(recipientRole) {
+    this.mailbox.delete(recipientRole);
+  }
+  updateStepStatus(stepId, status, result) {
+    const step = this.plan.steps.find((s) => s.id === stepId);
+    if (!step) return;
+    step.status = status;
+    if (result) {
+      step.result = result;
+      this.putArtifact(result);
+    }
+    this.plan.updatedAt = Date.now();
+  }
+  getNextRunnableSteps() {
+    const completed = new Set(
+      this.plan.steps.filter((s) => s.status === "completed").map((s) => s.id)
+    );
+    return this.plan.steps.filter(
+      (s) => s.status === "pending" && s.dependsOn.every((dep) => completed.has(dep))
+    );
+  }
+  toJSON() {
+    return {
+      taskId: this.taskId,
+      plan: this.plan,
+      artifacts: Array.from(this.artifacts.values()),
+      mailbox: Object.fromEntries(this.mailbox.entries())
+    };
+  }
+  static fromJSON(data) {
+    const ws = new TaskWorkspace(data.taskId, data.plan);
+    for (const artifact of data.artifacts || []) {
+      ws.artifacts.set(artifact.id, artifact);
+    }
+    for (const [key, messages] of Object.entries(data.mailbox || {})) {
+      ws.mailbox.set(key, messages);
+    }
+    return ws;
+  }
+}
+const CHECKPOINT_KEY_PREFIX = "ai_task_checkpoint_";
+const REGISTRY_KEY = "ai_task_checkpoint_registry";
+class TaskCheckpointService {
+  async save(workspace) {
+    const key = `${CHECKPOINT_KEY_PREFIX}${workspace.taskId}`;
+    await appSettings.set(key, workspace.toJSON());
+  }
+  async restore(taskId) {
+    const key = `${CHECKPOINT_KEY_PREFIX}${taskId}`;
+    const data = await appSettings.get(key);
+    if (!data) return null;
+    return TaskWorkspace.fromJSON(data);
+  }
+  async delete(taskId) {
+    const key = `${CHECKPOINT_KEY_PREFIX}${taskId}`;
+    await appSettings.set(key, void 0);
+  }
+  async listCheckpoints() {
+    return this.getRegistry();
+  }
+  async registerCheckpoint(taskId) {
+    const registry = await this.getRegistry();
+    if (!registry.includes(taskId)) {
+      registry.push(taskId);
+      await appSettings.set(REGISTRY_KEY, registry);
+    }
+  }
+  async unregisterCheckpoint(taskId) {
+    const registry = await this.getRegistry();
+    await appSettings.set(REGISTRY_KEY, registry.filter((id) => id !== taskId));
+  }
+  async getRegistry() {
+    return await appSettings.get(REGISTRY_KEY) || [];
+  }
+}
+const taskCheckpointService = new TaskCheckpointService();
+class TaskRunner {
+  constructor(executeStep) {
+    this.executeStep = executeStep;
+  }
+  async run(workspace, options) {
+    const plan = workspace.plan;
+    plan.status = "running";
+    await taskCheckpointService.save(workspace);
+    const errors = /* @__PURE__ */ new Map();
+    while (true) {
+      if (options.signal?.aborted) {
+        plan.status = "paused";
+        break;
+      }
+      const runnableSteps = getNextRunnableSteps(plan);
+      if (runnableSteps.length === 0) break;
+      await Promise.all(runnableSteps.map(async (step) => {
+        workspace.updateStepStatus(step.id, "running");
+        options.onStepStart?.(step);
+        try {
+          const artifact = await this.executeStep(step, workspace, options);
+          workspace.updateStepStatus(step.id, "completed", artifact);
+          options.onStepComplete?.(step, artifact);
+          await taskCheckpointService.save(workspace);
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          workspace.updateStepStatus(step.id, "failed");
+          errors.set(step.id, err);
+          options.onStepError?.(step, err);
+        }
+      }));
+      if (isPlanFailed(plan)) {
+        plan.status = "failed";
+        break;
+      }
+      if (isPlanComplete(plan)) {
+        plan.status = "completed";
+        break;
+      }
+    }
+    const artifacts = plan.steps.filter((s) => s.result).map((s) => s.result);
+    return { plan, artifacts, errors };
+  }
+}
+class OrchestratedWorkflowStrategy {
+  async execute(contributions, options, results, executeAgent) {
+    const chatConfig = options.chatConfig;
+    if (!chatConfig) throw new Error("Chat config is required");
+    const prompt = options.chatContext.history[options.chatContext.history.length - 1]?.content || "";
+    const providerFactory = new ProviderFactory();
+    const plan = await orchestrateTask({
+      prompt,
+      availableAgents: contributions,
+      chatConfig,
+      context: options.callContext.getProxy(),
+      executeCompletion: (messages, cfg) => streamToText(messages, cfg, providerFactory)
+    });
+    const workspace = new TaskWorkspace(`wf-${Date.now()}`, plan);
+    const byRole = new Map(contributions.map((c) => [c.role, c]));
+    const runner = new TaskRunner(async (step, ws, _opts) => {
+      const contrib = byRole.get(step.role) || contributions[0];
+      const stepMessages = [
+        ...options.chatContext.history,
+        { role: "user", content: step.subTask }
+      ];
+      const finalMessage = await executeAgent(contrib, stepMessages, results.sharedState, chatConfig, options, results);
+      const content = finalMessage?.content || "";
+      const artifact = {
+        id: step.produces[0] || `${step.id}-result`,
+        type: "text",
+        content,
+        producedBy: step.role,
+        createdAt: Date.now()
+      };
+      return artifact;
+    });
+    const taskResult = await runner.run(workspace, {
+      prompt,
+      chatConfig,
+      callContext: options.callContext,
+      signal: options.signal
+    });
+    const combined = taskResult.artifacts.map((a) => a.content).filter(Boolean).join("\n\n");
+    if (combined) {
+      results.messages.set("orchestrator", { role: "assistant", content: combined });
+    }
+  }
+}
+const REVIEWER_SYS_PROMPT = `You are a quality reviewer. Evaluate the provided artifact against the original task.
+
+Respond with ONLY a JSON object:
+{
+  "verdict": "approved" | "needs-revision",
+  "score": 0-100,
+  "notes": "<feedback for revision, empty if approved>"
+}`;
+async function reviewArtifact(options) {
+  const messages = [
+    { role: "system", content: REVIEWER_SYS_PROMPT },
+    { role: "user", content: `Original task: ${options.originalTask}
+
+Artifact to review:
+${options.artifact.content}` }
+  ];
+  try {
+    const responseText = await options.executeCompletion(messages, options.chatConfig);
+    const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) throw new Error("No JSON in reviewer response");
+    const parsed = JSON.parse(jsonMatch[0]);
+    return {
+      verdict: parsed.verdict === "approved" ? "approved" : "needs-revision",
+      score: typeof parsed.score === "number" ? parsed.score : 50,
+      notes: parsed.notes || ""
+    };
+  } catch {
+    return { verdict: "approved", score: 70, notes: "" };
+  }
+}
+class ReviewWorkflowStrategy {
+  async execute(contributions, options, results, executeAgent) {
+    const chatConfig = options.chatConfig;
+    if (!chatConfig) throw new Error("Chat config is required");
+    const providerFactory = new ProviderFactory();
+    const producer = contributions[0];
+    const reviewer = contributions.find((c) => c.reviewerFor?.includes(producer.role));
+    const maxRevisions = producer.maxRevisions ?? 2;
+    let currentMessages = [...options.chatContext.history];
+    let revisions = 0;
+    while (revisions <= maxRevisions) {
+      const finalMessage = await executeAgent(producer, currentMessages, results.sharedState, chatConfig, options, results);
+      if (!finalMessage) break;
+      if (!reviewer) {
+        results.messages.set(producer.role, finalMessage);
+        break;
+      }
+      const artifact = {
+        id: `draft-${revisions}`,
+        type: "text",
+        content: finalMessage.content,
+        producedBy: producer.role,
+        createdAt: Date.now()
+      };
+      const originalPrompt = options.chatContext.history[options.chatContext.history.length - 1]?.content || "";
+      const review = await reviewArtifact({
+        artifact,
+        originalTask: originalPrompt,
+        chatConfig,
+        executeCompletion: (messages, cfg) => streamToText(messages, cfg, providerFactory)
+      });
+      if (review.verdict === "approved" || revisions >= maxRevisions) {
+        results.messages.set(producer.role, finalMessage);
+        break;
+      }
+      currentMessages = [
+        ...options.chatContext.history,
+        finalMessage,
+        { role: "user", content: `Please revise based on this feedback: ${review.notes}` }
+      ];
+      revisions++;
+    }
+  }
+}
+class WorkflowEngine {
+  constructor() {
+    this.strategies = /* @__PURE__ */ new Map([
+      ["parallel", new ParallelWorkflowStrategy()],
+      ["sequential", new SequentialWorkflowStrategy()],
+      ["conditional", new ConditionalWorkflowStrategy()],
+      ["pipeline", new PipelineWorkflowStrategy()],
+      ["orchestrated", new OrchestratedWorkflowStrategy()],
+      ["review", new ReviewWorkflowStrategy()]
+    ]);
+  }
+  registerStrategy(name, strategy) {
+    this.strategies.set(name, strategy);
+  }
+  async execute(contributions, options, executeAgent) {
+    const workflowId = `workflow-${Date.now()}-${Math.random()}`;
+    const execution = options.execution || "parallel";
+    const results = {
+      messages: /* @__PURE__ */ new Map(),
+      sharedState: { ...options.sharedState || {} },
+      errors: /* @__PURE__ */ new Map()
+    };
+    publish(TOPIC_AGENT_WORKFLOW_STARTED, { workflowId, options });
+    try {
+      const strategy = this.strategies.get(execution);
+      if (!strategy) throw new Error(`Unknown workflow execution strategy: ${execution}`);
+      await strategy.execute(contributions, options, results, executeAgent);
+      publish(TOPIC_AGENT_WORKFLOW_COMPLETE, { workflowId, results });
+      return results;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      publish(TOPIC_AGENT_WORKFLOW_ERROR, { workflowId, error: err });
+      throw err;
+    }
+  }
+}
+const _TokenEstimator = class _TokenEstimator {
+  static estimateTokens(text) {
+    if (!text?.trim()) return 0;
+    const trimmed = text.trim();
+    return Math.max(1, Math.ceil(trimmed.length / this.AVERAGE_CHARS_PER_TOKEN + trimmed.split(/\s+/).filter((w) => w.length > 0).length * 0.3));
+  }
+  static estimateMessageTokens(message) {
+    let tokens = this.MESSAGE_OVERHEAD;
+    if (message.content) tokens += this.estimateTokens(message.content);
+    if (message.role) tokens += this.estimateTokens(message.role);
+    if (message.tool_calls) {
+      for (const tc of message.tool_calls) {
+        tokens += this.estimateTokens(tc.function.name || "") + this.estimateTokens(tc.function.arguments || "{}") + this.TOOL_CALL_OVERHEAD;
+      }
+    }
+    if (message.tool_call_id) tokens += this.estimateTokens(message.tool_call_id);
+    return tokens;
+  }
+  static estimatePromptTokens(messages, tools) {
+    let total = messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0);
+    if (tools?.length) {
+      for (const tool of tools) {
+        total += this.TOOL_DEFINITION_OVERHEAD;
+        total += this.estimateTokens(tool.function.name || "");
+        total += this.estimateTokens(tool.function.description || "");
+        if (tool.function.parameters) total += this.estimateTokens(JSON.stringify(tool.function.parameters));
+      }
+    }
+    return total;
+  }
+  static estimateCompletionTokens(content, toolCalls) {
+    let tokens = this.estimateTokens(content);
+    if (toolCalls?.length) {
+      for (const tc of toolCalls) {
+        tokens += this.TOOL_CALL_OVERHEAD + this.estimateTokens(tc.function?.name || "") + this.estimateTokens(tc.function?.arguments || "{}");
+      }
+    }
+    return tokens;
+  }
+};
+_TokenEstimator.AVERAGE_CHARS_PER_TOKEN = 4;
+_TokenEstimator.TOOL_DEFINITION_OVERHEAD = 50;
+_TokenEstimator.TOOL_CALL_OVERHEAD = 10;
+_TokenEstimator.MESSAGE_OVERHEAD = 4;
+let TokenEstimator = _TokenEstimator;
+const TOKEN_USAGE_KEY = "ai_token_usage";
+const EMPTY_USAGE = { promptTokens: 0, completionTokens: 0, totalTokens: 0, requestCount: 0 };
+class TokenUsageTracker {
+  constructor() {
+    this.data = null;
+    this.loadPromise = null;
+  }
+  async loadData() {
+    if (this.data) return this.data;
+    if (this.loadPromise) return this.loadPromise;
+    this.loadPromise = (async () => {
+      const stored = await persistenceService.getObject(TOKEN_USAGE_KEY);
+      this.data = stored ? stored : { providers: {}, total: { ...EMPTY_USAGE }, lastUpdated: Date.now() };
+      if (!this.data) {
+        this.data = { providers: {}, total: { ...EMPTY_USAGE }, lastUpdated: Date.now() };
+        await this.saveData();
+      }
+      this.loadPromise = null;
+      return this.data;
+    })();
+    return this.loadPromise;
+  }
+  async saveData() {
+    if (!this.data) return;
+    this.data.lastUpdated = Date.now();
+    await persistenceService.persistObject(TOKEN_USAGE_KEY, this.data);
+  }
+  async recordUsage(providerName, usage) {
+    await this.loadData();
+    if (!this.data) return;
+    this.data.providers[providerName] ??= { ...EMPTY_USAGE };
+    const provider = this.data.providers[providerName];
+    provider.promptTokens += usage.promptTokens;
+    provider.completionTokens += usage.completionTokens;
+    provider.totalTokens += usage.totalTokens;
+    provider.requestCount += 1;
+    this.data.total.promptTokens += usage.promptTokens;
+    this.data.total.completionTokens += usage.completionTokens;
+    this.data.total.totalTokens += usage.totalTokens;
+    this.data.total.requestCount += 1;
+    await this.saveData();
+  }
+  async getProviderUsage(providerName) {
+    await this.loadData();
+    return this.data?.providers[providerName] || null;
+  }
+  async getAllProviderUsage() {
+    await this.loadData();
+    return this.data?.providers || {};
+  }
+  async getTotalUsage() {
+    await this.loadData();
+    return this.data?.total || { ...EMPTY_USAGE };
+  }
+  async reset() {
+    this.data = { providers: {}, total: { ...EMPTY_USAGE }, lastUpdated: Date.now() };
+    await this.saveData();
+  }
+  async resetProvider(providerName) {
+    await this.loadData();
+    if (!this.data) return;
+    const provider = this.data.providers[providerName];
+    if (!provider) return;
+    this.data.total.promptTokens -= provider.promptTokens;
+    this.data.total.completionTokens -= provider.completionTokens;
+    this.data.total.totalTokens -= provider.totalTokens;
+    this.data.total.requestCount -= provider.requestCount;
+    delete this.data.providers[providerName];
+    await this.saveData();
+  }
+}
+const tokenUsageTracker = new TokenUsageTracker();
+class AIService {
+  constructor() {
+    this.activeRequests = /* @__PURE__ */ new Map();
+    this.activeTasks = /* @__PURE__ */ new Map();
+    this.toolRegistry = new ToolRegistry();
+    this.providerFactory = new ProviderFactory();
+    this.agentRegistry = new AgentRegistry();
+    this._promptBuilder = new PromptBuilder(this.toolRegistry);
+    this.messageProcessor = new MessageProcessorService();
+    this.toolExecutor = new ToolExecutor();
+    this.workflowEngine = new WorkflowEngine();
+    subscribe(TOPIC_SETTINGS_CHANGED, () => {
+      this.aiConfig = void 0;
+      this.configCheckPromise = void 0;
+      this.checkAIConfig().then();
+    });
+    this.checkAIConfig().then();
+  }
+  get promptBuilder() {
+    return this._promptBuilder;
+  }
+  getAgentContributions() {
+    return this.agentRegistry.getAgentContributions();
+  }
+  async getProviders() {
+    await this.checkAIConfig();
+    return this.aiConfig?.providers || [];
+  }
+  async getDefaultProvider() {
+    await this.checkAIConfig();
+    const providers = await this.getProviders();
+    if (this.aiConfig?.defaultProvider) {
+      const config = providers.find((p) => p.name === this.aiConfig?.defaultProvider);
+      if (config) return config;
+    }
+    return providers[0];
+  }
+  async setDefaultProvider(defaultProviderName) {
+    await this.checkAIConfig();
+    if (this.aiConfig) {
+      this.aiConfig.defaultProvider = defaultProviderName;
+      await appSettings.set(KEY_AI_CONFIG, this.aiConfig);
+    }
+    return this.getDefaultProvider();
+  }
+  createMessage(prompt) {
+    return { role: "user", content: prompt };
+  }
+  registerStreamingFetcher(provider) {
+    this.providerFactory.registerProvider(provider);
+  }
+  getContributedProviders() {
+    const contributions = contributionRegistry.getContributions(CID_CHAT_PROVIDERS);
+    return contributions.map((c) => c.provider);
+  }
+  mergeProviders(existing, contributed) {
+    const existingNames = new Set(existing.map((p) => p.name));
+    const missing = contributed.filter((p) => !existingNames.has(p.name));
+    return missing.length > 0 ? [...existing, ...missing] : existing;
+  }
+  async createInitialConfig() {
+    const initialConfig = { ...AI_CONFIG_TEMPLATE, providers: this.getContributedProviders() };
+    await appSettings.set(KEY_AI_CONFIG, initialConfig);
+    return appSettings.get(KEY_AI_CONFIG);
+  }
+  async updateConfigWithMissingProviders(config) {
+    const merged = this.mergeProviders(config.providers, this.getContributedProviders());
+    if (merged.length === config.providers.length) return config;
+    const updated = { ...config, providers: merged };
+    await appSettings.set(KEY_AI_CONFIG, updated);
+    return updated;
+  }
+  async checkAIConfig() {
+    if (this.aiConfig) return;
+    if (this.configCheckPromise) return this.configCheckPromise;
+    this.configCheckPromise = this.performConfigCheck();
+    return this.configCheckPromise;
+  }
+  async performConfigCheck() {
+    try {
+      this.aiConfig = await appSettings.get(KEY_AI_CONFIG);
+      this.aiConfig = this.aiConfig ? await this.updateConfigWithMissingProviders(this.aiConfig) : await this.createInitialConfig();
+      publish(TOPIC_AICONFIG_CHANGED, this.aiConfig);
+    } finally {
+      this.configCheckPromise = void 0;
+    }
+  }
+  createAgentContext(sharedState, callContext, additional = {}) {
+    return { ...sharedState, ...callContext.getProxy(), ...additional };
+  }
+  async *streamCompletion(options) {
+    const requestId = `${Date.now()}-${Math.random()}`;
+    const abortController = new AbortController();
+    this.activeRequests.set(requestId, abortController);
+    if (options.signal) {
+      options.signal.addEventListener("abort", () => abortController.abort());
+    }
+    const effectiveSignal = options.signal || abortController.signal;
+    try {
+      options.onStatus?.("starting");
+      publish(TOPIC_AI_STREAM_STARTED, { requestId, options });
+      const chatConfig = options.chatConfig || await this.getDefaultProvider();
+      const messages = sanitizeMessagesForAPI(options.chatContext.history);
+      const provider = this.providerFactory.getProvider(chatConfig);
+      const accumulator = this.toolExecutor.createToolCallAccumulator();
+      let accumulatedContent = "";
+      let accumulatedRole = "assistant";
+      let tokenUsage;
+      for await (const chunk of provider.stream({
+        model: chatConfig.model,
+        messages,
+        chatConfig,
+        tools: options.tools,
+        signal: effectiveSignal
+      })) {
+        if (chunk.type === "error") {
+          options.onStatus?.("error");
+          publish(TOPIC_AI_STREAM_ERROR, { requestId, chunk });
+          yield chunk;
+          break;
+        }
+        if (chunk.type === "token") {
+          accumulator.processChunk(chunk);
+          if (!chunk.toolCalls?.length) accumulatedContent += chunk.content;
+          if (chunk.message?.role) accumulatedRole = chunk.message.role;
+          if (chunk.content) options.onToken?.(chunk.content);
+          options.onStatus?.("streaming");
+          options.onProgress?.({ received: accumulatedContent.length });
+          publish(TOPIC_AI_STREAM_CHUNK, { requestId, chunk });
+          yield chunk;
+        } else if (chunk.type === "done") {
+          if (chunk.metadata?.usage) tokenUsage = chunk.metadata.usage;
+          options.onStatus?.("complete");
+          publish(TOPIC_AI_STREAM_COMPLETE, { requestId });
+          yield chunk;
+          break;
+        } else {
+          yield chunk;
+        }
+      }
+      const finalToolCalls = accumulator.getFinalToolCalls();
+      const finalMessage = {
+        role: accumulatedRole,
+        content: accumulatedContent,
+        ...finalToolCalls.length > 0 && { toolCalls: finalToolCalls }
+      };
+      if (!tokenUsage) {
+        const promptTokens = TokenEstimator.estimatePromptTokens(messages, options.tools);
+        const completionTokens = TokenEstimator.estimateCompletionTokens(accumulatedContent, finalToolCalls);
+        tokenUsage = { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens, estimated: true };
+      }
+      tokenUsageTracker.recordUsage(chatConfig.name, tokenUsage).catch((err) => {
+        logger$1.error(`Failed to record token usage: ${err instanceof Error ? err.message : String(err)}`);
+      });
+      return { message: finalMessage, tokenUsage };
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        options.onStatus?.("error");
+        publish(TOPIC_AI_STREAM_ERROR, { requestId, error: "Request cancelled" });
+        throw error;
+      }
+      options.onStatus?.("error");
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      publish(TOPIC_AI_STREAM_ERROR, { requestId, error: errorMessage });
+      yield { type: "error", content: errorMessage, metadata: { error } };
+      throw error;
+    } finally {
+      this.activeRequests.delete(requestId);
+    }
+  }
+  async handleStreamingPromptDirect(options) {
+    const stream = this.streamCompletion(options);
+    let lastValue;
+    while (true) {
+      lastValue = await stream.next();
+      if (lastValue.done) return lastValue.value.message;
+      const chunk = lastValue.value;
+      if (chunk.type === "error") throw new Error(chunk.content);
+      if (chunk.type === "done") {
+        const final = await stream.next();
+        if (final.done && final.value) return final.value.message;
+        if (!final.done) continue;
+        throw new Error("Stream completed without return value");
+      }
+    }
+  }
+  async handleStreamingPrompt(options) {
+    const callContext = options.callContext || rootContext.createChild({});
+    const agentContext = this.createAgentContext(
+      {},
+      callContext,
+      { userPrompt: options.chatContext.history[options.chatContext.history.length - 1]?.content || "" }
+    );
+    const matchingAgents = this.agentRegistry.getMatchingAgents(agentContext);
+    const roles = matchingAgents.length > 0 ? matchingAgents.map((a) => a.role) : ["assistant"];
+    const workflowResult = await this.executeAgentWorkflow({
+      chatContext: options.chatContext,
+      chatConfig: options.chatConfig,
+      callContext,
+      execution: "parallel",
+      stream: options.stream,
+      signal: options.signal,
+      onToken: (_role, token) => options.onToken?.(token),
+      onStatus: (_role, status) => options.onStatus?.(status),
+      roles
+    });
+    const messages = Array.from(workflowResult.messages.values());
+    return messages.length === 1 ? messages[0] : messages;
+  }
+  cancelRequest(requestId) {
+    const controller = this.activeRequests.get(requestId);
+    if (!controller) return false;
+    controller.abort();
+    this.activeRequests.delete(requestId);
+    return true;
+  }
+  async executeAgentWorkflow(options) {
+    const agentContext = this.createAgentContext(options.sharedState || {}, options.callContext);
+    const matchingAgents = this.agentRegistry.getMatchingAgents(agentContext, options.roles);
+    return this.workflowEngine.execute(
+      matchingAgents,
+      options,
+      (contrib, messages, sharedState, chatConfig, workflowOptions, results) => this.executeAgent(contrib, messages, sharedState, chatConfig, workflowOptions, results)
+    );
+  }
+  async executeAgent(contrib, messages, sharedState, chatConfig, options, results) {
+    options.onAgentStart?.(contrib.role);
+    const agentContext = this.createAgentContext(sharedState, options.callContext, {
+      userPrompt: messages[messages.length - 1]?.content || ""
+    });
+    const { messages: preparedMessages, tools } = await this._promptBuilder.build(
+      contrib,
+      messages,
+      agentContext,
+      contrib.hooks
+    );
+    const chatMessages = preparedMessages.map((msg) => {
+      const chatMsg = { role: msg.role, content: msg.content };
+      if (msg.tool_call_id) chatMsg.tool_call_id = msg.tool_call_id;
+      if (msg.tool_calls) chatMsg.tool_calls = msg.tool_calls;
+      return chatMsg;
+    });
+    let rawMessage = await this.handleStreamingPromptDirect({
+      chatContext: { history: chatMessages },
+      chatConfig,
+      callContext: options.callContext,
+      stream: options.stream ?? true,
+      signal: options.signal,
+      onToken: options.onToken ? (token) => options.onToken(contrib.role, token) : void 0,
+      tools
+    });
+    let toolCallIteration = 0;
+    const conversationHistory = [...preparedMessages];
+    while (rawMessage.toolCalls && rawMessage.toolCalls.length > 0) {
+      toolCallIteration++;
+      if (toolCallIteration > MAX_TOOL_ITERATIONS) {
+        console.warn(`[AIService] Max tool call iterations reached`);
+        break;
+      }
+      let toolResults;
+      if (options.requireToolApproval && options.onToolApprovalRequest) {
+        const toolCallDescriptions = rawMessage.toolCalls.map((tc) => {
+          let parsedArgs = {};
+          try {
+            parsedArgs = JSON.parse(tc.function.arguments || "{}");
+          } catch {
+          }
+          return `${tc.function.name}(${Object.entries(parsedArgs).map(([k, v]) => `${k}=${v}`).join(", ")})`;
+        }).join(", ");
+        const approvalRequest = {
+          toolCalls: rawMessage.toolCalls,
+          message: `The AI wants to execute: ${toolCallDescriptions}`
+        };
+        const approved = await options.onToolApprovalRequest(contrib.role, approvalRequest);
+        if (!approved) {
+          toolResults = rawMessage.toolCalls.map((tc) => ({
+            id: tc.id,
+            result: { success: false, message: "Tool execution cancelled by user", cancelled: true }
+          }));
+        } else {
+          toolResults = await this.toolExecutor.executeToolCalls(rawMessage.toolCalls, agentContext);
+        }
+      } else {
+        toolResults = await this.toolExecutor.executeToolCalls(rawMessage.toolCalls, agentContext);
+      }
+      const toolMessages = toolResults.map((tr) => ({
+        role: "tool",
+        content: tr.error ? JSON.stringify({ error: tr.error }) : JSON.stringify(tr.result),
+        tool_call_id: tr.id
+      }));
+      const assistantMessage = {
+        role: "assistant",
+        content: rawMessage.content || ""
+      };
+      if (rawMessage.toolCalls?.length) {
+        assistantMessage.tool_calls = rawMessage.toolCalls.filter((tc) => tc.function.name?.trim()).map((tc) => ({ id: tc.id, type: tc.type, function: { name: tc.function.name, arguments: tc.function.arguments || "{}" } }));
+      }
+      conversationHistory.push(assistantMessage, ...toolMessages);
+      rawMessage = await this.handleStreamingPromptDirect({
+        chatContext: {
+          history: conversationHistory.map((m) => ({
+            role: m.role,
+            content: m.content,
+            ...m.tool_call_id && { tool_call_id: m.tool_call_id },
+            ...m.tool_calls && { tool_calls: m.tool_calls }
+          }))
+        },
+        chatConfig,
+        callContext: options.callContext,
+        stream: options.stream ?? true,
+        signal: options.signal,
+        tools
+      });
+      if (rawMessage.content?.trim() && !rawMessage.toolCalls?.length) break;
+    }
+    const processedMessage = await this.messageProcessor.process(
+      rawMessage,
+      contrib,
+      this.createAgentContext(sharedState, options.callContext, { message: rawMessage })
+    );
+    if (contrib.hooks?.afterReceive) {
+      await contrib.hooks.afterReceive(processedMessage, this.createAgentContext(sharedState, options.callContext));
+    }
+    const finalMessage = { role: contrib.role, content: processedMessage.content };
+    results.messages.set(contrib.role, finalMessage);
+    options.onAgentComplete?.(contrib.role, finalMessage);
+    return finalMessage;
+  }
+  async planTask(prompt, context) {
+    const chatConfig = await this.getDefaultProvider();
+    const contributions = this.agentRegistry.getAgentContributions();
+    rootContext.createChild({});
+    return orchestrateTask({
+      prompt,
+      availableAgents: contributions,
+      chatConfig,
+      context,
+      executeCompletion: (messages, cfg) => streamToText(messages, cfg, this.providerFactory)
+    });
+  }
+  async executeTask(options) {
+    const chatConfig = options.chatConfig || await this.getDefaultProvider();
+    const callContext = options.callContext || rootContext.createChild({});
+    const contributions = this.agentRegistry.getAgentContributions();
+    const plan = await this.planTask(options.prompt, callContext.getProxy());
+    options.onPlanReady?.(plan);
+    const workspace = new TaskWorkspace(`task-${Date.now()}`, plan);
+    await taskCheckpointService.registerCheckpoint(workspace.taskId);
+    const abortController = new AbortController();
+    this.activeTasks.set(workspace.taskId, abortController);
+    const taskOptions = { ...options, signal: options.signal ?? abortController.signal };
+    const byRole = new Map(contributions.map((c) => [c.role, c]));
+    const runner = new TaskRunner(this.createStepExecutor(byRole, contributions, chatConfig, callContext, taskOptions));
+    try {
+      const result = await runner.run(workspace, taskOptions);
+      await taskCheckpointService.unregisterCheckpoint(workspace.taskId);
+      return result;
+    } finally {
+      this.activeTasks.delete(workspace.taskId);
+    }
+  }
+  async resumeTask(taskId, options) {
+    const workspace = await taskCheckpointService.restore(taskId);
+    if (!workspace) throw new Error(`No checkpoint found for task ${taskId}`);
+    const chatConfig = options.chatConfig || await this.getDefaultProvider();
+    const callContext = options.callContext || rootContext.createChild({});
+    const contributions = this.agentRegistry.getAgentContributions();
+    const byRole = new Map(contributions.map((c) => [c.role, c]));
+    const runner = new TaskRunner(this.createStepExecutor(byRole, contributions, chatConfig, callContext, options));
+    return runner.run(workspace, options);
+  }
+  createStepExecutor(byRole, contributions, chatConfig, callContext, options) {
+    return async (step, _ws, _opts) => {
+      const contrib = byRole.get(step.role) || contributions[0];
+      const stepMessages = [
+        ...options.chatContext?.history || [],
+        { role: "user", content: step.subTask }
+      ];
+      const workflowResult = await this.workflowEngine.execute(
+        [contrib],
+        { chatContext: { history: stepMessages }, chatConfig, callContext, execution: "parallel", stream: true, signal: options.signal, roles: [contrib.role] },
+        (c, msgs, state, cfg, wopts, results) => this.executeAgent(c, msgs, state, cfg, wopts, results)
+      );
+      const msg = workflowResult.messages.get(contrib.role);
+      return {
+        id: step.produces[0] || `${step.id}-result`,
+        type: "text",
+        content: msg?.content || "",
+        producedBy: step.role,
+        createdAt: Date.now()
+      };
+    };
+  }
+  cancelTask(taskId) {
+    const controller = this.activeTasks.get(taskId);
+    if (controller) {
+      controller.abort();
+      this.activeTasks.delete(taskId);
+    }
+  }
+}
+const aiService = new AIService();
+export {
+  AI_CONFIG_TEMPLATE as A,
+  BaseProvider as B,
+  CID_AGENTS as C,
+  DEFAULT_AGENT_ROLE as D,
+  aiService as E,
+  extractBaseUrl as F,
+  sanitizeFunctionName as G,
+  streamToText as H,
+  EMPTY_USAGE as I,
+  tokenUsageTracker as J,
+  KEY_AI_CONFIG as K,
+  MAX_RECENT_TOOL_CALLS as M,
+  OllamaParser as O,
+  ParallelWorkflowStrategy as P,
+  ReviewWorkflowStrategy as R,
+  SSEParser as S,
+  TOPIC_AGENT_WORKFLOW_COMPLETE as T,
+  WorkflowEngine as W,
+  AgentRegistry as a,
+  BaseSequentialWorkflow as b,
+  CID_CHAT_PROVIDERS as c,
+  CID_PROMPT_ENHANCERS as d,
+  ConditionalWorkflowStrategy as e,
+  MAX_TOOL_ITERATIONS as f,
+  MessageProcessorService as g,
+  OllamaProvider as h,
+  OpenAIProvider as i,
+  OrchestratedWorkflowStrategy as j,
+  PipelineWorkflowStrategy as k,
+  PromptBuilder as l,
+  ProviderFactory as m,
+  SequentialWorkflowStrategy as n,
+  StreamParser as o,
+  TOPIC_AGENT_WORKFLOW_ERROR as p,
+  TOPIC_AGENT_WORKFLOW_STARTED as q,
+  TOPIC_AICONFIG_CHANGED as r,
+  TOPIC_AI_STREAM_CHUNK as s,
+  TOPIC_AI_STREAM_COMPLETE as t,
+  TOPIC_AI_STREAM_ERROR as u,
+  TOPIC_AI_STREAM_STARTED as v,
+  TokenEstimator as w,
+  ToolCallAccumulator as x,
+  ToolExecutor as y,
+  ToolRegistry as z
+};
+//# sourceMappingURL=ai-service-CGdlV3FV.js.map