@gendive/chatllm 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2058 @@
+// src/types.ts
+var DEFAULT_PERSONALIZATION = {
+  responseStyle: {
+    warmth: "medium",
+    enthusiasm: "medium",
+    emojiUsage: "low",
+    formatting: "default",
+    verbosity: "balanced"
+  },
+  userProfile: {},
+  useMemory: true,
+  language: "auto"
+};
+
+// src/providers/base.ts
+var BaseProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Generate a unique message ID
+   */
+  generateMessageId() {
+    return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+};
+var ProviderRegistry = class {
+  providers = /* @__PURE__ */ new Map();
+  register(provider) {
+    this.providers.set(provider.name, provider);
+  }
+  get(name) {
+    return this.providers.get(name);
+  }
+  has(name) {
+    return this.providers.has(name);
+  }
+  getAll() {
+    return this.providers;
+  }
+};
+
+// src/config.ts
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_STORAGE_PATH = join(homedir(), ".devdive-chat");
+var DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
+var DEFAULT_MODELS = {
+  openai: "gpt-4",
+  anthropic: "claude-3-opus-20240229",
+  google: "gemini-pro",
+  naver: "HCX-003",
+  ollama: "llama2"
+};
+function validateProviderConfig(provider, config) {
+  const providerConfig = config.providers[provider];
+  if (!providerConfig) {
+    throw new Error(`Provider "${provider}" is not configured`);
+  }
+  switch (provider) {
+    case "openai":
+      if (!("apiKey" in providerConfig) || !providerConfig.apiKey) {
+        throw new Error("OpenAI provider requires apiKey");
+      }
+      break;
+    case "anthropic":
+      if (!("apiKey" in providerConfig) || !providerConfig.apiKey) {
+        throw new Error("Anthropic provider requires apiKey");
+      }
+      break;
+    case "google":
+      if (!("apiKey" in providerConfig) || !providerConfig.apiKey) {
+        throw new Error("Google provider requires apiKey");
+      }
+      break;
+    case "naver":
+      if (!("apiKey" in providerConfig) || !providerConfig.apiKey || !("apiGatewayKey" in providerConfig) || !providerConfig.apiGatewayKey) {
+        throw new Error("Naver provider requires apiKey and apiGatewayKey");
+      }
+      break;
+    case "ollama":
+      break;
+  }
+}
+function getProviderBaseUrl(provider, config) {
+  const providerConfig = config.providers[provider];
+  switch (provider) {
+    case "openai":
+      return providerConfig?.baseUrl ?? "https://api.openai.com/v1";
+    case "anthropic":
+      return providerConfig?.baseUrl ?? "https://api.anthropic.com";
+    case "google":
+      return "https://generativelanguage.googleapis.com";
+    case "naver":
+      return providerConfig?.baseUrl ?? "https://clovastudio.apigw.ntruss.com";
+    case "ollama":
+      return providerConfig?.baseUrl ?? DEFAULT_OLLAMA_BASE_URL;
+  }
+}
+function getDefaultModel(provider, config) {
+  return config.defaultModel ?? DEFAULT_MODELS[provider];
+}
+function mergeConfig(userConfig) {
+  return {
+    ...userConfig,
+    storagePath: userConfig.storagePath ?? DEFAULT_STORAGE_PATH
+  };
+}
+
+// src/utils/errors.ts
+var ChatLLMError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ChatLLMError";
+  }
+};
+var ProviderError = class extends ChatLLMError {
+  constructor(provider, message, statusCode, originalError) {
+    super(`[${provider}] ${message}`);
+    this.provider = provider;
+    this.statusCode = statusCode;
+    this.originalError = originalError;
+    this.name = "ProviderError";
+  }
+};
+var ConfigurationError = class extends ChatLLMError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var ToolExecutionError = class extends ChatLLMError {
+  constructor(toolName, message, originalError) {
+    super(`Tool "${toolName}" execution failed: ${message}`);
+    this.toolName = toolName;
+    this.originalError = originalError;
+    this.name = "ToolExecutionError";
+  }
+};
+var StorageError = class extends ChatLLMError {
+  constructor(operation, message, originalError) {
+    super(`Storage ${operation} failed: ${message}`);
+    this.operation = operation;
+    this.originalError = originalError;
+    this.name = "StorageError";
+  }
+};
+var StreamError = class extends ChatLLMError {
+  constructor(message, originalError) {
+    super(message);
+    this.originalError = originalError;
+    this.name = "StreamError";
+  }
+};
+var ValidationError = class extends ChatLLMError {
+  constructor(field, message) {
+    super(`Validation error for "${field}": ${message}`);
+    this.field = field;
+    this.name = "ValidationError";
+  }
+};
+function wrapProviderError(provider, error, statusCode) {
+  if (error instanceof ProviderError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  const originalError = error instanceof Error ? error : void 0;
+  return new ProviderError(provider, message, statusCode, originalError);
+}
+function isProviderError(error) {
+  return error instanceof ProviderError;
+}
+function isToolExecutionError(error) {
+  return error instanceof ToolExecutionError;
+}
+function isStorageError(error) {
+  return error instanceof StorageError;
+}
+
+// src/utils/stream.ts
+async function* parseSSEStream(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new StreamError("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("data: ")) {
+          const data = trimmed.slice(6);
+          if (data !== "[DONE]") {
+            yield data;
+          }
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const trimmed = buffer.trim();
+      if (trimmed.startsWith("data: ")) {
+        const data = trimmed.slice(6);
+        if (data !== "[DONE]") {
+          yield data;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* parseNDJSONStream(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new StreamError("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          try {
+            yield JSON.parse(trimmed);
+          } catch {
+          }
+        }
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        yield JSON.parse(buffer.trim());
+      } catch {
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function createStreamEvent(type, data) {
+  return {
+    type,
+    ...data
+  };
+}
+async function collectStreamContent(stream) {
+  let content = "";
+  for await (const event of stream) {
+    if (event.type === "text" && event.content) {
+      content += event.content;
+    }
+  }
+  return content;
+}
+
+// src/providers/ollama.ts
+var OllamaProvider = class extends BaseProvider {
+  name = "ollama";
+  baseUrl;
+  constructor(config) {
+    super(config);
+    this.baseUrl = getProviderBaseUrl("ollama", config);
+  }
+  /**
+   * Send a message and get a complete response
+   */
+  async sendMessage(messages, options) {
+    const formattedMessages = this.formatMessages(messages);
+    const tools = options.tools ? this.formatTools(options.tools) : void 0;
+    const body = this.buildRequestBody(formattedMessages, options, tools);
+    try {
+      const response = await fetch(this.getEndpoint(options.model || "llama2"), {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw wrapProviderError("ollama", errorText, response.status);
+      }
+      const data = await response.json();
+      return this.parseResponse(data);
+    } catch (error) {
+      throw wrapProviderError("ollama", error);
+    }
+  }
+  /**
+   * Send a message and stream the response
+   */
+  async *sendMessageStream(messages, options) {
+    const formattedMessages = this.formatMessages(messages);
+    const tools = options.tools ? this.formatTools(options.tools) : void 0;
+    const body = this.buildRequestBody(formattedMessages, options, tools);
+    body.stream = true;
+    try {
+      const response = await fetch(this.getEndpoint(options.model || "llama2"), {
+        method: "POST",
+        headers: this.getHeaders(),
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        yield createStreamEvent("error", {
+          error: wrapProviderError("ollama", errorText, response.status)
+        });
+        return;
+      }
+      let fullContent = "";
+      const toolCalls = [];
+      for await (const chunk of parseNDJSONStream(response)) {
+        const data = chunk;
+        if (data.message?.content) {
+          fullContent += data.message.content;
+          yield createStreamEvent("text", { content: data.message.content });
+        }
+        if (data.message?.tool_calls) {
+          for (const tc of data.message.tool_calls) {
+            const toolCall = {
+              id: `call_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+              name: tc.function.name,
+              arguments: tc.function.arguments
+            };
+            toolCalls.push(toolCall);
+            yield createStreamEvent("tool_call", { toolCall });
+          }
+        }
+        if (data.done) {
+          const message = {
+            id: this.generateMessageId(),
+            role: "assistant",
+            content: fullContent,
+            provider: "ollama",
+            model: data.model,
+            toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+            timestamp: Date.now()
+          };
+          yield createStreamEvent("done", { message });
+          return;
+        }
+      }
+    } catch (error) {
+      yield createStreamEvent("error", {
+        error: wrapProviderError("ollama", error)
+      });
+    }
+  }
+  /**
+   * Convert internal message format to Ollama format
+   */
+  formatMessages(messages) {
+    return messages.map((msg) => {
+      const formatted = {
+        role: msg.role,
+        content: msg.content
+      };
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        formatted.tool_calls = msg.toolCalls.map((tc) => ({
+          function: {
+            name: tc.name,
+            arguments: tc.arguments
+          }
+        }));
+      }
+      return formatted;
+    });
+  }
+  /**
+   * Convert tool definitions to Ollama format
+   */
+  formatTools(tools) {
+    return tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: "object",
+          properties: tool.parameters.properties,
+          required: tool.parameters.required
+        }
+      }
+    }));
+  }
+  /**
+   * Parse Ollama response into internal message format
+   */
+  parseResponse(response) {
+    const toolCalls = [];
+    if (response.message.tool_calls) {
+      for (const tc of response.message.tool_calls) {
+        toolCalls.push({
+          id: `call_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+          name: tc.function.name,
+          arguments: tc.function.arguments
+        });
+      }
+    }
+    return {
+      id: this.generateMessageId(),
+      role: "assistant",
+      content: response.message.content,
+      provider: "ollama",
+      model: response.model,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Get the Ollama API endpoint
+   */
+  getEndpoint(_model) {
+    return `${this.baseUrl}/api/chat`;
+  }
+  /**
+   * Get headers for Ollama API requests
+   */
+  getHeaders() {
+    return {
+      "Content-Type": "application/json"
+    };
+  }
+  /**
+   * Build request body for Ollama API
+   */
+  buildRequestBody(messages, options, tools) {
+    const body = {
+      model: options.model || "llama2",
+      messages,
+      stream: false
+    };
+    if (options.temperature !== void 0 || options.maxTokens !== void 0) {
+      body.options = {};
+      if (options.temperature !== void 0) {
+        body.options.temperature = options.temperature;
+      }
+      if (options.maxTokens !== void 0) {
+        body.options.num_predict = options.maxTokens;
+      }
+    }
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+    }
+    return body;
+  }
+  /**
+   * List available models from Ollama
+   */
+  async listModels() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!response.ok) {
+        throw wrapProviderError("ollama", "Failed to list models", response.status);
+      }
+      const data = await response.json();
+      return data.models.map((m) => m.name);
+    } catch (error) {
+      throw wrapProviderError("ollama", error);
+    }
+  }
+  /**
+   * Check if Ollama server is available
+   */
+  async isAvailable() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/message.ts
+function generateMessageId() {
+  return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function createMessage(role, content, options) {
+  return {
+    id: generateMessageId(),
+    role,
+    content,
+    provider: options?.provider,
+    model: options?.model,
+    toolCalls: options?.toolCalls,
+    toolCallId: options?.toolCallId,
+    timestamp: Date.now(),
+    metadata: options?.metadata
+  };
+}
+function createUserMessage(content) {
+  return createMessage("user", content);
+}
+function createAssistantMessage(content, provider, model, toolCalls) {
+  return createMessage("assistant", content, { provider, model, toolCalls });
+}
+function createSystemMessage(content) {
+  return createMessage("system", content);
+}
+function createToolMessage(content, toolCallId) {
+  return createMessage("tool", content, { toolCallId });
+}
+function cloneMessage(message, overrides) {
+  return {
+    ...message,
+    ...overrides,
+    id: overrides?.id ?? generateMessageId(),
+    timestamp: overrides?.timestamp ?? Date.now()
+  };
+}
+function filterByRole(messages, role) {
+  return messages.filter((m) => m.role === role);
+}
+function filterByProvider(messages, provider) {
+  return messages.filter((m) => m.provider === provider);
+}
+function getLastMessageByRole(messages, role) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === role) {
+      return messages[i];
+    }
+  }
+  return void 0;
+}
+function getTotalContentLength(messages) {
+  return messages.reduce((sum, msg) => sum + msg.content.length, 0);
+}
+function truncateMessages(messages, maxTokens, preserveSystem = true) {
+  const maxChars = maxTokens * 4;
+  const result = [];
+  let currentLength = 0;
+  if (preserveSystem) {
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        result.push(msg);
+        currentLength += msg.content.length;
+      }
+    }
+  }
+  const nonSystemMessages = messages.filter((m) => m.role !== "system");
+  for (let i = nonSystemMessages.length - 1; i >= 0; i--) {
+    const msg = nonSystemMessages[i];
+    if (currentLength + msg.content.length <= maxChars) {
+      result.unshift(msg);
+      currentLength += msg.content.length;
+    } else {
+      break;
+    }
+  }
+  return result.sort((a, b) => {
+    if (a.role === "system" && b.role !== "system") return -1;
+    if (a.role !== "system" && b.role === "system") return 1;
+    return a.timestamp - b.timestamp;
+  });
+}
+function formatMessagesForDisplay(messages) {
+  return messages.map((msg) => {
+    const provider = msg.provider ? ` [${msg.provider}/${msg.model}]` : "";
+    const prefix = `[${msg.role.toUpperCase()}]${provider}`;
+    return `${prefix}: ${msg.content.substring(0, 100)}${msg.content.length > 100 ? "..." : ""}`;
+  }).join("\n");
+}
+
+// src/core/session.ts
+function generateSessionId() {
+  return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function createSession(options) {
+  const now = Date.now();
+  return {
+    id: options?.id ?? generateSessionId(),
+    messages: [],
+    systemPrompt: options?.systemPrompt,
+    createdAt: now,
+    updatedAt: now,
+    metadata: options?.metadata ?? {}
+  };
+}
+function addMessage(session, message) {
+  return {
+    ...session,
+    messages: [...session.messages, message],
+    updatedAt: Date.now()
+  };
+}
+function addMessages(session, messages) {
+  return {
+    ...session,
+    messages: [...session.messages, ...messages],
+    updatedAt: Date.now()
+  };
+}
+function getMessagesForProvider(session, _provider) {
+  const messages = [];
+  if (session.systemPrompt) {
+    messages.push(createSystemMessage(session.systemPrompt));
+  }
+  messages.push(...session.messages);
+  return messages;
+}
+function setSystemPrompt(session, prompt) {
+  return {
+    ...session,
+    systemPrompt: prompt,
+    updatedAt: Date.now()
+  };
+}
+function clearMessages(session) {
+  return {
+    ...session,
+    messages: [],
+    updatedAt: Date.now()
+  };
+}
+function getLastMessages(session, count) {
+  return session.messages.slice(-count);
+}
+function getMessagesAfter(session, timestamp) {
+  return session.messages.filter((m) => m.timestamp > timestamp);
+}
+function getSessionSummary(session) {
+  const providers = /* @__PURE__ */ new Set();
+  let firstMessageAt = null;
+  let lastMessageAt = null;
+  for (const msg of session.messages) {
+    if (msg.provider) {
+      providers.add(msg.provider);
+    }
+    if (firstMessageAt === null || msg.timestamp < firstMessageAt) {
+      firstMessageAt = msg.timestamp;
+    }
+    if (lastMessageAt === null || msg.timestamp > lastMessageAt) {
+      lastMessageAt = msg.timestamp;
+    }
+  }
+  return {
+    id: session.id,
+    messageCount: session.messages.length,
+    providers: Array.from(providers),
+    firstMessageAt,
+    lastMessageAt
+  };
+}
+function setSessionMetadata(session, key, value) {
+  return {
+    ...session,
+    metadata: {
+      ...session.metadata,
+      [key]: value
+    },
+    updatedAt: Date.now()
+  };
+}
+function serializeSession(session) {
+  return {
+    id: session.id,
+    messages: session.messages,
+    systemPrompt: session.systemPrompt,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    metadata: session.metadata
+  };
+}
+function deserializeSession(data) {
+  return {
+    id: data.id,
+    messages: data.messages,
+    systemPrompt: data.systemPrompt,
+    createdAt: data.createdAt,
+    updatedAt: data.updatedAt,
+    metadata: data.metadata ?? {}
+  };
+}
+
+// src/core/chat.ts
+function generateChatId() {
+  return `chat_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var chatStates = /* @__PURE__ */ new Map();
+function createChat(config) {
+  const mergedConfig = mergeConfig(config);
+  const chatId = config.id ?? generateChatId();
+  const providerRegistry = new ProviderRegistry();
+  if (config.providers.ollama !== void 0 || config.defaultProvider === "ollama") {
+    providerRegistry.register(new OllamaProvider(mergedConfig));
+  }
+  if (!providerRegistry.has(config.defaultProvider)) {
+    if (config.defaultProvider === "ollama") {
+      providerRegistry.register(new OllamaProvider(mergedConfig));
+    } else {
+      throw new ConfigurationError(
+        `Default provider "${config.defaultProvider}" is not configured`
+      );
+    }
+  }
+  const now = Date.now();
+  const chat = {
+    id: chatId,
+    config: mergedConfig,
+    messages: [],
+    tools: /* @__PURE__ */ new Map(),
+    memory: /* @__PURE__ */ new Map(),
+    createdAt: now,
+    updatedAt: now
+  };
+  const session = createSession({
+    systemPrompt: config.systemPrompt
+  });
+  chatStates.set(chatId, {
+    chat,
+    session,
+    providerRegistry
+  });
+  return chat;
+}
+function getChatState(chat) {
+  const state = chatStates.get(chat.id);
+  if (!state) {
+    throw new ConfigurationError(`Chat "${chat.id}" not found`);
+  }
+  return state;
+}
+function getProvider(chat, providerType) {
+  const state = getChatState(chat);
+  const type = providerType ?? chat.config.defaultProvider;
+  const provider = state.providerRegistry.get(type);
+  if (!provider) {
+    throw new ConfigurationError(`Provider "${type}" is not available`);
+  }
+  return provider;
+}
+async function sendMessage(chat, content, options) {
+  const state = getChatState(chat);
+  const provider = getProvider(chat, options?.provider);
+  const model = options?.model ?? getDefaultModel(provider.name, chat.config);
+  const userMessage = createUserMessage(content);
+  state.session = addMessage(state.session, userMessage);
+  chat.messages.push(userMessage);
+  const messages = getMessagesForProvider(state.session, provider.name);
+  const tools = options?.tools ?? Array.from(chat.tools.values());
+  const sendOptions = {
+    ...options,
+    model,
+    tools: tools.length > 0 ? tools : void 0
+  };
+  const response = await provider.sendMessage(messages, sendOptions);
+  state.session = addMessage(state.session, response);
+  chat.messages.push(response);
+  chat.updatedAt = Date.now();
+  if (response.toolCalls && response.toolCalls.length > 0) {
+    return await handleToolCalls(chat, response, sendOptions);
+  }
+  return response;
+}
+async function* sendMessageStream(chat, content, options) {
+  const state = getChatState(chat);
+  const provider = getProvider(chat, options?.provider);
+  const model = options?.model ?? getDefaultModel(provider.name, chat.config);
+  const userMessage = createUserMessage(content);
+  state.session = addMessage(state.session, userMessage);
+  chat.messages.push(userMessage);
+  const messages = getMessagesForProvider(state.session, provider.name);
+  const tools = options?.tools ?? Array.from(chat.tools.values());
+  const sendOptions = {
+    ...options,
+    model,
+    tools: tools.length > 0 ? tools : void 0
+  };
+  for await (const event of provider.sendMessageStream(messages, sendOptions)) {
+    yield event;
+    if (event.type === "done" && event.message) {
+      state.session = addMessage(state.session, event.message);
+      chat.messages.push(event.message);
+      chat.updatedAt = Date.now();
+    }
+  }
+}
+async function handleToolCalls(chat, response, options) {
+  const state = getChatState(chat);
+  const provider = getProvider(chat, options.provider);
+  if (!response.toolCalls) {
+    return response;
+  }
+  for (const toolCall of response.toolCalls) {
+    const tool = chat.tools.get(toolCall.name);
+    if (!tool) {
+      const errorMessage = createAssistantMessage(
+        `Tool "${toolCall.name}" not found`,
+        provider.name,
+        options.model
+      );
+      state.session = addMessage(state.session, errorMessage);
+      continue;
+    }
+    try {
+      const result = await tool.handler(toolCall.arguments);
+      const toolResultMessage = {
+        id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+        role: "tool",
+        content: JSON.stringify(result),
+        toolCallId: toolCall.id,
+        timestamp: Date.now()
+      };
+      state.session = addMessage(state.session, toolResultMessage);
+      chat.messages.push(toolResultMessage);
+    } catch (error) {
+      const errorContent = error instanceof Error ? error.message : String(error);
+      const toolErrorMessage = {
+        id: `msg_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+        role: "tool",
+        content: JSON.stringify({ error: errorContent }),
+        toolCallId: toolCall.id,
+        timestamp: Date.now()
+      };
+      state.session = addMessage(state.session, toolErrorMessage);
+      chat.messages.push(toolErrorMessage);
+    }
+  }
+  const messages = getMessagesForProvider(state.session, provider.name);
+  const finalResponse = await provider.sendMessage(messages, options);
+  state.session = addMessage(state.session, finalResponse);
+  chat.messages.push(finalResponse);
+  chat.updatedAt = Date.now();
+  if (finalResponse.toolCalls && finalResponse.toolCalls.length > 0) {
+    return handleToolCalls(chat, finalResponse, options);
+  }
+  return finalResponse;
+}
+function registerTool(chat, tool) {
+  chat.tools.set(tool.name, tool);
+  chat.updatedAt = Date.now();
+}
+function unregisterTool(chat, toolName) {
+  const deleted = chat.tools.delete(toolName);
+  if (deleted) {
+    chat.updatedAt = Date.now();
+  }
+  return deleted;
+}
+function getTools(chat) {
+  return Array.from(chat.tools.values());
+}
+function setSystemPrompt2(chat, prompt) {
+  const state = getChatState(chat);
+  state.session.systemPrompt = prompt;
+  chat.config.systemPrompt = prompt;
+  chat.updatedAt = Date.now();
+}
+function getMessages(chat) {
+  return [...chat.messages];
+}
+function clearMessages2(chat) {
+  const state = getChatState(chat);
+  chat.messages = [];
+  state.session.messages = [];
+  chat.updatedAt = Date.now();
+}
+function resetChat(chat) {
+  const state = getChatState(chat);
+  chat.messages = [];
+  state.session.messages = [];
+  chat.tools.clear();
+  chat.memory.clear();
+  const now = Date.now();
+  chat.updatedAt = now;
+  state.session.updatedAt = now;
+}
+function getSession(chat) {
+  const state = getChatState(chat);
+  return state.session;
+}
+function destroyChat(chat) {
+  chatStates.delete(chat.id);
+}
+
+// src/memory/storage.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { join as join2, dirname } from "path";
+var FileStorage = class {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+    this.ensureDirectory(basePath);
+  }
+  /**
+   * Ensure a directory exists
+   */
+  ensureDirectory(path) {
+    if (!existsSync(path)) {
+      try {
+        mkdirSync(path, { recursive: true });
+      } catch (error) {
+        throw new StorageError(
+          "write",
+          `Failed to create directory: ${path}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+  }
+  /**
+   * Get the full path for a key
+   */
+  getFilePath(key) {
+    const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return join2(this.basePath, `${sanitizedKey}.json`);
+  }
+  /**
+   * Read data from storage
+   */
+  read(key) {
+    const filePath = this.getFilePath(key);
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      throw new StorageError(
+        "read",
+        `Failed to read key: ${key}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Write data to storage
+   */
+  write(key, data) {
+    const filePath = this.getFilePath(key);
+    try {
+      this.ensureDirectory(dirname(filePath));
+      writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+    } catch (error) {
+      throw new StorageError(
+        "write",
+        `Failed to write key: ${key}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Delete data from storage
+   */
+  delete(key) {
+    const filePath = this.getFilePath(key);
+    if (!existsSync(filePath)) {
+      return false;
+    }
+    try {
+      unlinkSync(filePath);
+      return true;
+    } catch (error) {
+      throw new StorageError(
+        "delete",
+        `Failed to delete key: ${key}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Check if a key exists
+   */
+  exists(key) {
+    return existsSync(this.getFilePath(key));
+  }
+  /**
+   * Get the base path
+   */
+  getBasePath() {
+    return this.basePath;
+  }
+};
+var MemoryStorage = class {
+  data = /* @__PURE__ */ new Map();
+  read(key) {
+    const value = this.data.get(key);
+    return value !== void 0 ? value : null;
+  }
+  write(key, data) {
+    this.data.set(key, data);
+  }
+  delete(key) {
+    return this.data.delete(key);
+  }
+  exists(key) {
+    return this.data.has(key);
+  }
+  clear() {
+    this.data.clear();
+  }
+  getAll() {
+    return new Map(this.data);
+  }
+};
+
+// src/memory/global.ts
+import { join as join3 } from "path";
+var GlobalMemoryStore = class {
+  entries = /* @__PURE__ */ new Map();
+  storage;
+  storageKey = "global_memory";
+  autoSave;
+  constructor(storagePath, autoSave = true) {
+    this.autoSave = autoSave;
+    if (storagePath) {
+      this.storage = new FileStorage(join3(storagePath, "memory"));
+      this.load();
+    } else {
+      this.storage = new MemoryStorage();
+    }
+  }
+  /**
+   * Load entries from storage
+   */
+  load() {
+    const data = this.storage.read(this.storageKey);
+    if (data) {
+      this.entries = new Map(Object.entries(data));
+    }
+  }
+  /**
+   * Save entries to storage
+   */
+  save() {
+    if (!this.autoSave) return;
+    const data = {};
+    for (const [key, value] of this.entries) {
+      data[key] = value;
+    }
+    this.storage.write(this.storageKey, data);
+  }
+  /**
+   * Set a memory entry
+   */
+  set(key, value) {
+    const now = Date.now();
+    const existing = this.entries.get(key);
+    this.entries.set(key, {
+      key,
+      value,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now
+    });
+    this.save();
+  }
+  /**
+   * Get a memory entry value
+   */
+  get(key) {
+    const entry = this.entries.get(key);
+    return entry?.value;
+  }
+  /**
+   * Get a memory entry with metadata
+   */
+  getEntry(key) {
+    return this.entries.get(key);
+  }
+  /**
+   * Check if a key exists
+   */
+  has(key) {
+    return this.entries.has(key);
+  }
+  /**
+   * Delete a memory entry
+   */
+  delete(key) {
+    const deleted = this.entries.delete(key);
+    if (deleted) {
+      this.save();
+    }
+    return deleted;
+  }
+  /**
+   * Get all memory entries
+   */
+  getAll() {
+    return new Map(this.entries);
+  }
+  /**
+   * Get all keys
+   */
+  keys() {
+    return Array.from(this.entries.keys());
+  }
+  /**
+   * Clear all entries
+   */
+  clear() {
+    this.entries.clear();
+    this.save();
+  }
+  /**
+   * Get entries count
+   */
+  size() {
+    return this.entries.size;
+  }
+  /**
+   * Force save to storage
+   */
+  forceSave() {
+    const originalAutoSave = this.autoSave;
+    this.autoSave = true;
+    this.save();
+    this.autoSave = originalAutoSave;
+  }
+  /**
+   * Convert entries to a format suitable for system prompt injection
+   */
+  toPromptContext() {
+    if (this.entries.size === 0) {
+      return "";
+    }
+    const lines = ["[Global Memory]"];
+    for (const [key, entry] of this.entries) {
+      const valueStr = typeof entry.value === "object" ? JSON.stringify(entry.value) : String(entry.value);
+      lines.push(`- ${key}: ${valueStr}`);
+    }
+    return lines.join("\n");
+  }
+};
+var globalMemoryInstance = null;
+function initGlobalMemory(storagePath, autoSave = true) {
+  globalMemoryInstance = new GlobalMemoryStore(storagePath ?? DEFAULT_STORAGE_PATH, autoSave);
+}
+function getGlobalMemoryStore() {
+  if (!globalMemoryInstance) {
+    globalMemoryInstance = new GlobalMemoryStore();
+  }
+  return globalMemoryInstance;
+}
+function setGlobalMemory(key, value) {
+  getGlobalMemoryStore().set(key, value);
+}
+function getGlobalMemory(key) {
+  return getGlobalMemoryStore().get(key);
+}
+function deleteGlobalMemory(key) {
+  return getGlobalMemoryStore().delete(key);
+}
+function hasGlobalMemory(key) {
+  return getGlobalMemoryStore().has(key);
+}
+function getGlobalMemoryKeys() {
+  return getGlobalMemoryStore().keys();
+}
+function clearGlobalMemory() {
+  getGlobalMemoryStore().clear();
+}
+function getGlobalMemoryContext() {
+  return getGlobalMemoryStore().toPromptContext();
+}
+
+// src/memory/chat.ts
+import { join as join4 } from "path";
+var ChatMemoryStore = class {
+  storage;
+  autoSave;
+  constructor(storagePath, autoSave = true) {
+    this.autoSave = autoSave;
+    if (storagePath) {
+      this.storage = new FileStorage(join4(storagePath, "chat_memory"));
+    } else {
+      this.storage = new MemoryStorage();
+    }
+  }
+  /**
+   * Get storage key for a chat
+   */
+  getChatKey(chatId) {
+    return `chat_${chatId}`;
+  }
+  /**
+   * Load chat memory from storage
+   */
+  loadChatMemory(chatId) {
+    const data = this.storage.read(this.getChatKey(chatId));
+    if (data) {
+      return new Map(Object.entries(data));
+    }
+    return /* @__PURE__ */ new Map();
+  }
+  /**
+   * Save chat memory to storage
+   */
+  saveChatMemory(chatId, entries) {
+    if (!this.autoSave) return;
+    const data = {};
+    for (const [key, value] of entries) {
+      data[key] = value;
+    }
+    this.storage.write(this.getChatKey(chatId), data);
+  }
+  /**
+   * Set a memory entry for a chat
+   */
+  set(chatId, key, value) {
+    const entries = this.loadChatMemory(chatId);
+    const now = Date.now();
+    const existing = entries.get(key);
+    entries.set(key, {
+      key,
+      value,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now
+    });
+    this.saveChatMemory(chatId, entries);
+  }
+  /**
+   * Get a memory entry value for a chat
+   */
+  get(chatId, key) {
+    const entries = this.loadChatMemory(chatId);
+    const entry = entries.get(key);
+    return entry?.value;
+  }
+  /**
+   * Get a memory entry with metadata
+   */
+  getEntry(chatId, key) {
+    const entries = this.loadChatMemory(chatId);
+    return entries.get(key);
+  }
+  /**
+   * Check if a key exists for a chat
+   */
+  has(chatId, key) {
+    const entries = this.loadChatMemory(chatId);
+    return entries.has(key);
+  }
+  /**
+   * Delete a memory entry for a chat
+   */
+  delete(chatId, key) {
+    const entries = this.loadChatMemory(chatId);
+    const deleted = entries.delete(key);
+    if (deleted) {
+      this.saveChatMemory(chatId, entries);
+    }
+    return deleted;
+  }
+  /**
+   * Get all memory entries for a chat
+   */
+  getAll(chatId) {
+    return this.loadChatMemory(chatId);
+  }
+  /**
+   * Get all keys for a chat
+   */
+  keys(chatId) {
+    const entries = this.loadChatMemory(chatId);
+    return Array.from(entries.keys());
+  }
+  /**
+   * Clear all entries for a chat
+   */
+  clear(chatId) {
+    this.storage.delete(this.getChatKey(chatId));
+  }
+  /**
+   * Get entries count for a chat
+   */
+  size(chatId) {
+    const entries = this.loadChatMemory(chatId);
+    return entries.size;
+  }
+  /**
+   * Convert chat memory to a format suitable for system prompt injection
+   */
+  toPromptContext(chatId) {
+    const entries = this.loadChatMemory(chatId);
+    if (entries.size === 0) {
+      return "";
+    }
+    const lines = ["[Chat Memory]"];
+    for (const [key, entry] of entries) {
+      const valueStr = typeof entry.value === "object" ? JSON.stringify(entry.value) : String(entry.value);
+      lines.push(`- ${key}: ${valueStr}`);
+    }
+    return lines.join("\n");
+  }
+};
+var chatMemoryInstance = null;
+function initChatMemory(storagePath, autoSave = true) {
+  chatMemoryInstance = new ChatMemoryStore(storagePath, autoSave);
+}
+function getChatMemoryStore() {
+  if (!chatMemoryInstance) {
+    chatMemoryInstance = new ChatMemoryStore();
+  }
+  return chatMemoryInstance;
+}
+function setChatMemory(chat, key, value) {
+  getChatMemoryStore().set(chat.id, key, value);
+  const now = Date.now();
+  const existing = chat.memory.get(key);
+  chat.memory.set(key, {
+    key,
+    value,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now
+  });
+}
+function getChatMemory(chat, key) {
+  const internalEntry = chat.memory.get(key);
+  if (internalEntry) {
+    return internalEntry.value;
+  }
+  return getChatMemoryStore().get(chat.id, key);
+}
+function deleteChatMemory(chat, key) {
+  chat.memory.delete(key);
+  return getChatMemoryStore().delete(chat.id, key);
+}
+function hasChatMemory(chat, key) {
+  return chat.memory.has(key) || getChatMemoryStore().has(chat.id, key);
+}
+function getChatMemoryKeys(chat) {
+  const internalKeys = Array.from(chat.memory.keys());
+  const storedKeys = getChatMemoryStore().keys(chat.id);
+  return [.../* @__PURE__ */ new Set([...internalKeys, ...storedKeys])];
+}
+function clearChatMemory(chat) {
+  chat.memory.clear();
+  getChatMemoryStore().clear(chat.id);
+}
+function getChatMemoryContext(chat) {
+  return getChatMemoryStore().toPromptContext(chat.id);
+}
+function syncChatMemory(chat) {
+  for (const [key, entry] of chat.memory) {
+    getChatMemoryStore().set(chat.id, key, entry.value);
+  }
+}
+
+// src/memory/manager.ts
+function initMemory(config = {}) {
+  initGlobalMemory(config.storagePath, config.autoSave);
+  initChatMemory(config.storagePath, config.autoSave);
+}
+function getMemoryContext(chat) {
+  const globalContext = getGlobalMemoryContext();
+  const chatContext = getChatMemoryContext(chat);
+  const parts = [];
+  if (globalContext) {
+    parts.push(globalContext);
+  }
+  if (chatContext) {
+    parts.push(chatContext);
+  }
+  return parts.join("\n\n");
+}
+function buildSystemPromptWithMemory(basePrompt, chat) {
+  const memoryContext = getMemoryContext(chat);
+  if (!memoryContext) {
+    return basePrompt;
+  }
+  return `${basePrompt}
+
+---
+${memoryContext}
+---`;
+}
+
+// src/acontext/observer.ts
+var observerStates = /* @__PURE__ */ new Map();
+var observerCallbacks = /* @__PURE__ */ new Map();
+var DEFAULT_OBSERVER_CONFIG = {
+  extractTasks: true,
+  extractPreferences: true,
+  autoLearn: false
+};
+function generateId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function getState(chatId) {
+  let state = observerStates.get(chatId);
+  if (!state) {
+    state = {
+      enabled: false,
+      config: { ...DEFAULT_OBSERVER_CONFIG },
+      tasks: [],
+      preferences: []
+    };
+    observerStates.set(chatId, state);
+  }
+  return state;
+}
+function emitEvent(chatId, event) {
+  const callbacks = observerCallbacks.get(chatId) || [];
+  for (const callback of callbacks) {
+    try {
+      callback(event);
+    } catch (error) {
+      console.error("Observer callback error:", error);
+    }
+  }
+}
+function enableObserver(chat, config) {
+  const state = getState(chat.id);
+  state.enabled = true;
+  state.config = { ...DEFAULT_OBSERVER_CONFIG, ...config };
+  observerStates.set(chat.id, state);
+}
+function disableObserver(chat) {
+  const state = getState(chat.id);
+  state.enabled = false;
+  observerStates.set(chat.id, state);
+}
+function isObserverEnabled(chat) {
+  return getState(chat.id).enabled;
+}
+function getObserverConfig(chat) {
+  return { ...getState(chat.id).config };
+}
+function onObserverEvent(chat, callback) {
+  const callbacks = observerCallbacks.get(chat.id) || [];
+  callbacks.push(callback);
+  observerCallbacks.set(chat.id, callbacks);
+  return () => {
+    const currentCallbacks = observerCallbacks.get(chat.id) || [];
+    const index = currentCallbacks.indexOf(callback);
+    if (index > -1) {
+      currentCallbacks.splice(index, 1);
+      observerCallbacks.set(chat.id, currentCallbacks);
+    }
+  };
+}
+function analyzeMessages(chat, messages) {
+  const state = getState(chat.id);
+  if (!state.enabled) {
+    return { tasks: [], preferences: [] };
+  }
+  const messagesToAnalyze = messages || chat.messages;
+  const tasks = [];
+  const preferences = [];
+  for (const msg of messagesToAnalyze) {
+    if (msg.role === "user") {
+      const taskPatterns = [
+        /(?:해줘|해주세요|만들어|작성해|구현해|추가해|수정해|삭제해|찾아)/,
+        /(?:please|create|make|write|implement|add|update|delete|find)/i
+      ];
+      for (const pattern of taskPatterns) {
+        if (pattern.test(msg.content)) {
+          const description = msg.content.substring(0, 100).trim();
+          tasks.push({
+            description,
+            status: "pending",
+            progress: 0
+          });
+          break;
+        }
+      }
+      const preferencePatterns = [
+        { pattern: /한국어|korean/i, key: "language", value: "ko" },
+        { pattern: /영어|english/i, key: "language", value: "en" },
+        { pattern: /간단히|짧게|briefly/i, key: "response_length", value: "short" },
+        { pattern: /자세히|상세히|in detail/i, key: "response_length", value: "detailed" },
+        { pattern: /코드로|with code/i, key: "include_code", value: true }
+      ];
+      for (const { pattern, key, value } of preferencePatterns) {
+        if (pattern.test(msg.content)) {
+          preferences.push({
+            key,
+            value,
+            confidence: 0.7
+          });
+        }
+      }
+    }
+    if (msg.role === "assistant") {
+      const completionPatterns = [
+        /완료|완성|done|finished|completed/i
+      ];
+      for (const pattern of completionPatterns) {
+        if (pattern.test(msg.content) && tasks.length > 0) {
+          for (let i = tasks.length - 1; i >= 0; i--) {
+            if (tasks[i].status === "pending") {
+              tasks[i].status = "completed";
+              tasks[i].progress = 100;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  return { tasks, preferences };
+}
+function processMessages(chat, newMessages) {
+  const state = getState(chat.id);
+  if (!state.enabled) return;
+  const extraction = analyzeMessages(chat, newMessages);
+  const now = Date.now();
+  if (state.config.extractTasks) {
+    for (const extractedTask of extraction.tasks) {
+      const task = {
+        id: generateId("task"),
+        description: extractedTask.description,
+        status: extractedTask.status,
+        progress: extractedTask.progress,
+        createdAt: now,
+        updatedAt: now
+      };
+      state.tasks.push(task);
+      emitEvent(chat.id, {
+        type: "task_detected",
+        timestamp: now,
+        data: task
+      });
+    }
+  }
+  if (state.config.extractPreferences) {
+    for (const extractedPref of extraction.preferences) {
+      const existingIndex = state.preferences.findIndex((p) => p.key === extractedPref.key);
+      const preference = {
+        key: extractedPref.key,
+        value: extractedPref.value,
+        confidence: extractedPref.confidence,
+        source: `message_${newMessages[0]?.id || "unknown"}`
+      };
+      if (existingIndex >= 0) {
+        state.preferences[existingIndex] = preference;
+      } else {
+        state.preferences.push(preference);
+      }
+      emitEvent(chat.id, {
+        type: "preference_detected",
+        timestamp: now,
+        data: preference
+      });
+    }
+  }
+  observerStates.set(chat.id, state);
+}
+function getObservedTasks(chat) {
+  return [...getState(chat.id).tasks];
+}
+function getObservedPreferences(chat) {
+  return [...getState(chat.id).preferences];
+}
+function updateTaskStatus(chat, taskId, status, progress) {
+  const state = getState(chat.id);
+  const task = state.tasks.find((t) => t.id === taskId);
+  if (!task) return false;
+  task.status = status;
+  if (progress !== void 0) {
+    task.progress = progress;
+  }
+  task.updatedAt = Date.now();
+  emitEvent(chat.id, {
+    type: "task_updated",
+    timestamp: Date.now(),
+    data: task
+  });
+  observerStates.set(chat.id, state);
+  return true;
+}
+function clearObserverState(chat) {
+  observerStates.delete(chat.id);
+  observerCallbacks.delete(chat.id);
+}
+function getObserverState(chat) {
+  return { ...getState(chat.id) };
+}
+
+// src/acontext/learner.ts
+import { join as join5 } from "path";
+var SkillLearner = class {
+  storage;
+  skills = /* @__PURE__ */ new Map();
+  storageKey = "learned_skills";
+  constructor(storagePath) {
+    if (storagePath) {
+      this.storage = new FileStorage(join5(storagePath, "acontext"));
+      this.load();
+    } else {
+      this.storage = new MemoryStorage();
+    }
+  }
+  /**
+   * Load skills from storage
+   */
+  load() {
+    const data = this.storage.read(this.storageKey);
+    if (data) {
+      this.skills = new Map(Object.entries(data));
+    }
+  }
+  /**
+   * Save skills to storage
+   */
+  save() {
+    const data = {};
+    for (const [key, value] of this.skills) {
+      data[key] = value;
+    }
+    this.storage.write(this.storageKey, data);
+  }
+  /**
+   * Generate a unique skill ID
+   */
+  generateId() {
+    return `skill_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Extract category from task description
+   */
+  extractCategory(description) {
+    const categoryPatterns = [
+      [/여행|travel|trip/i, "travel"],
+      [/코드|code|programming|개발/i, "coding"],
+      [/글|write|작성|문서/i, "writing"],
+      [/분석|analyze|analysis/i, "analysis"],
+      [/검색|search|find|찾/i, "search"],
+      [/번역|translate/i, "translation"],
+      [/요약|summarize|summary/i, "summarization"]
+    ];
+    for (const [pattern, category] of categoryPatterns) {
+      if (pattern.test(description)) {
+        return category;
+      }
+    }
+    return "general";
+  }
+  /**
+   * Learn from a completed conversation
+   */
+  learn(input) {
+    const now = Date.now();
+    const skillId = this.generateId();
+    const category = this.extractCategory(input.taskDescription);
+    const steps = input.steps.map((step, index) => ({
+      order: index + 1,
+      action: this.summarizeAction(step),
+      expectedInput: this.extractInputPattern(step.userInput),
+      expectedOutput: this.extractOutputPattern(step.assistantOutput)
+    }));
+    const skill = {
+      id: skillId,
+      name: this.generateSkillName(input.taskDescription),
+      description: input.taskDescription,
+      category,
+      steps,
+      successRate: input.outcome === "success" ? 1 : input.outcome === "partial" ? 0.5 : 0,
+      usageCount: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.skills.set(skillId, skill);
+    this.save();
+    return skill;
+  }
+  /**
+   * Summarize an action from a learning step
+   */
+  summarizeAction(step) {
+    const summary = step.assistantOutput.substring(0, 100).trim();
+    if (step.toolsUsed && step.toolsUsed.length > 0) {
+      return `${summary} [Tools: ${step.toolsUsed.join(", ")}]`;
+    }
+    return summary;
+  }
+  /**
+   * Extract input pattern from user input
+   */
+  extractInputPattern(input) {
+    return input.substring(0, 50).trim();
+  }
+  /**
+   * Extract output pattern from assistant output
+   */
+  extractOutputPattern(output) {
+    return output.substring(0, 50).trim();
+  }
+  /**
+   * Generate a skill name from task description
+   */
+  generateSkillName(description) {
+    const name = description.substring(0, 30).trim();
+    return name.replace(/[^a-zA-Z0-9가-힣\s]/g, "").trim() || "Unnamed Skill";
+  }
+  /**
+   * Get a skill by ID
+   */
+  getSkill(skillId) {
+    return this.skills.get(skillId);
+  }
+  /**
+   * Get all skills
+   */
+  getAllSkills() {
+    return Array.from(this.skills.values());
+  }
+  /**
+   * Search skills by category
+   */
+  getSkillsByCategory(category) {
+    return this.getAllSkills().filter((s) => s.category === category);
+  }
+  /**
+   * Search skills by keyword
+   */
+  searchSkills(keyword) {
+    const lowerKeyword = keyword.toLowerCase();
+    return this.getAllSkills().filter(
+      (s) => s.name.toLowerCase().includes(lowerKeyword) || s.description.toLowerCase().includes(lowerKeyword) || s.category.toLowerCase().includes(lowerKeyword)
+    );
+  }
+  /**
+   * Update skill success rate
+   */
+  updateSuccessRate(skillId, success) {
+    const skill = this.skills.get(skillId);
+    if (!skill) return;
+    skill.usageCount += 1;
+    skill.successRate = (skill.successRate * (skill.usageCount - 1) + (success ? 1 : 0)) / skill.usageCount;
+    skill.updatedAt = Date.now();
+    this.skills.set(skillId, skill);
+    this.save();
+  }
+  /**
+   * Delete a skill
+   */
+  deleteSkill(skillId) {
+    const deleted = this.skills.delete(skillId);
+    if (deleted) {
+      this.save();
+    }
+    return deleted;
+  }
+  /**
+   * Clear all skills
+   */
+  clearSkills() {
+    this.skills.clear();
+    this.save();
+  }
+};
+var learnerInstance = null;
+function initLearner(storagePath) {
+  learnerInstance = new SkillLearner(storagePath ?? DEFAULT_STORAGE_PATH);
+}
+function getLearner() {
+  if (!learnerInstance) {
+    learnerInstance = new SkillLearner();
+  }
+  return learnerInstance;
+}
+function learnFromConversation(chat, taskDescription, outcome = "success") {
+  const steps = [];
+  let currentUserInput = "";
+  for (const msg of chat.messages) {
+    if (msg.role === "user") {
+      currentUserInput = msg.content;
+    } else if (msg.role === "assistant" && currentUserInput) {
+      steps.push({
+        userInput: currentUserInput,
+        assistantOutput: msg.content,
+        toolsUsed: msg.toolCalls?.map((tc) => tc.name)
+      });
+      currentUserInput = "";
+    }
+  }
+  return getLearner().learn({
+    taskDescription,
+    conversationSummary: `Conversation with ${chat.messages.length} messages`,
+    outcome,
+    steps
+  });
+}
+function getLearnedSkills(category) {
+  if (category) {
+    return getLearner().getSkillsByCategory(category);
+  }
+  return getLearner().getAllSkills();
+}
+function searchLearnedSkills(keyword) {
+  return getLearner().searchSkills(keyword);
+}
+function getLearnedSkill(skillId) {
+  return getLearner().getSkill(skillId);
+}
+function recordSkillUsage(skillId, success) {
+  getLearner().updateSuccessRate(skillId, success);
+}
+function deleteLearnedSkill(skillId) {
+  return getLearner().deleteSkill(skillId);
+}
+function clearLearnedSkills() {
+  getLearner().clearSkills();
+}
+
+// src/acontext/skills.ts
+function findRelevantSkills(query, options = {}) {
+  const { category, minSuccessRate = 0, limit = 10 } = options;
+  let skills = getLearnedSkills(category);
+  if (minSuccessRate > 0) {
+    skills = skills.filter((s) => s.successRate >= minSuccessRate);
+  }
+  const scoredSkills = skills.map((skill) => ({
+    skill,
+    score: calculateRelevanceScore(query, skill)
+  }));
+  scoredSkills.sort((a, b) => b.score - a.score);
+  return scoredSkills.filter((s) => s.score > 0).slice(0, limit).map((s) => s.skill);
+}
+function calculateRelevanceScore(query, skill) {
+  const lowerQuery = query.toLowerCase();
+  const words = lowerQuery.split(/\s+/).filter((w) => w.length > 1);
+  let score = 0;
+  const lowerName = skill.name.toLowerCase();
+  for (const word of words) {
+    if (lowerName.includes(word)) {
+      score += 3;
+    }
+  }
+  const lowerDesc = skill.description.toLowerCase();
+  for (const word of words) {
+    if (lowerDesc.includes(word)) {
+      score += 2;
+    }
+  }
+  if (lowerQuery.includes(skill.category)) {
+    score += 2;
+  }
+  score *= 0.5 + skill.successRate * 0.5;
+  score += Math.min(skill.usageCount * 0.1, 1);
+  return score;
+}
+function applySkill(_chat, skill) {
+  if (!skill || !skill.steps || skill.steps.length === 0) {
+    return {
+      applied: false,
+      skillId: skill?.id || "unknown",
+      error: "Invalid skill or no steps available"
+    };
+  }
+  try {
+    const suggestedPrompt = generateSkillPrompt(skill);
+    return {
+      applied: true,
+      skillId: skill.id,
+      suggestedPrompt
+    };
+  } catch (error) {
+    return {
+      applied: false,
+      skillId: skill.id,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+function generateSkillPrompt(skill) {
+  const lines = [
+    `[Skill: ${skill.name}]`,
+    "",
+    "Follow these steps:"
+  ];
+  for (const step of skill.steps) {
+    lines.push(`${step.order}. ${step.action}`);
+    if (step.expectedInput) {
+      lines.push(`   Input pattern: ${step.expectedInput}`);
+    }
+  }
+  return lines.join("\n");
+}
+function applySkillToSystemPrompt(chat, skill, baseSystemPrompt) {
+  const result = applySkill(chat, skill);
+  if (!result.applied || !result.suggestedPrompt) {
+    return baseSystemPrompt;
+  }
+  return `${baseSystemPrompt}
+
+---
+${result.suggestedPrompt}
+---`;
+}
+function getBestSkill(query, options = {}) {
+  const skills = findRelevantSkills(query, { ...options, limit: 1 });
+  return skills[0];
+}
+function suggestSkills(chat, limit = 3) {
+  const recentMessages = chat.messages.slice(-5);
+  const context = recentMessages.map((m) => m.content).join(" ");
+  return findRelevantSkills(context, { limit, minSuccessRate: 0.3 });
+}
+function recordSkillApplication(skillId, success) {
+  recordSkillUsage(skillId, success);
+}
+var skillApplicationHistory = /* @__PURE__ */ new Map();
+function trackSkillApplication(chatId, skillId) {
+  const history = skillApplicationHistory.get(chatId) || [];
+  history.push({
+    skillId,
+    appliedAt: Date.now()
+  });
+  skillApplicationHistory.set(chatId, history);
+}
+function updateSkillApplicationSuccess(chatId, skillId, success) {
+  const history = skillApplicationHistory.get(chatId) || [];
+  let application;
+  for (let i = history.length - 1; i >= 0; i--) {
+    if (history[i].skillId === skillId) {
+      application = history[i];
+      break;
+    }
+  }
+  if (application) {
+    application.success = success;
+    recordSkillApplication(skillId, success);
+  }
+}
+function getSkillApplicationHistory(chatId) {
+  return [...skillApplicationHistory.get(chatId) || []];
+}
+function clearSkillApplicationHistory(chatId) {
+  skillApplicationHistory.delete(chatId);
+}
+export {
+  BaseProvider,
+  ChatLLMError,
+  ConfigurationError,
+  DEFAULT_MODELS,
+  DEFAULT_OLLAMA_BASE_URL,
+  DEFAULT_PERSONALIZATION,
+  DEFAULT_STORAGE_PATH,
+  FileStorage,
+  MemoryStorage,
+  OllamaProvider,
+  ProviderError,
+  ProviderRegistry,
+  StorageError,
+  StreamError,
+  ToolExecutionError,
+  ValidationError,
+  addMessage as addSessionMessage,
+  addMessages as addSessionMessages,
+  analyzeMessages,
+  applySkill,
+  applySkillToSystemPrompt,
+  buildSystemPromptWithMemory,
+  clearChatMemory,
+  clearGlobalMemory,
+  clearLearnedSkills,
+  clearMessages2 as clearMessages,
+  clearObserverState,
+  clearMessages as clearSessionMessages,
+  clearSkillApplicationHistory,
+  cloneMessage,
+  collectStreamContent,
+  createAssistantMessage,
+  createChat,
+  createMessage,
+  createSession,
+  createStreamEvent,
+  createSystemMessage,
+  createToolMessage,
+  createUserMessage,
+  deleteChatMemory,
+  deleteGlobalMemory,
+  deleteLearnedSkill,
+  deserializeSession,
+  destroyChat,
+  disableObserver,
+  enableObserver,
+  filterByProvider,
+  filterByRole,
+  findRelevantSkills,
+  formatMessagesForDisplay,
+  getBestSkill,
+  getChatMemory,
+  getChatMemoryContext,
+  getChatMemoryKeys,
+  getDefaultModel,
+  getGlobalMemory,
+  getGlobalMemoryContext,
+  getGlobalMemoryKeys,
+  getGlobalMemoryStore,
+  getLastMessageByRole,
+  getLastMessages,
+  getLearnedSkill,
+  getLearnedSkills,
+  getMemoryContext,
+  getMessages,
+  getMessagesAfter,
+  getMessagesForProvider,
+  getObservedPreferences,
+  getObservedTasks,
+  getObserverConfig,
+  getObserverState,
+  getProviderBaseUrl,
+  getSession,
+  getSessionSummary,
+  getSkillApplicationHistory,
+  getTools,
+  getTotalContentLength,
+  hasChatMemory,
+  hasGlobalMemory,
+  initChatMemory,
+  initGlobalMemory,
+  initLearner,
+  initMemory,
+  isObserverEnabled,
+  isProviderError,
+  isStorageError,
+  isToolExecutionError,
+  learnFromConversation,
+  mergeConfig,
+  onObserverEvent,
+  parseNDJSONStream,
+  parseSSEStream,
+  processMessages,
+  recordSkillApplication,
+  recordSkillUsage,
+  registerTool,
+  resetChat,
+  searchLearnedSkills,
+  sendMessage,
+  sendMessageStream,
+  serializeSession,
+  setChatMemory,
+  setGlobalMemory,
+  setSessionMetadata,
+  setSystemPrompt as setSessionSystemPrompt,
+  setSystemPrompt2 as setSystemPrompt,
+  suggestSkills,
+  syncChatMemory,
+  trackSkillApplication,
+  truncateMessages,
+  unregisterTool,
+  updateSkillApplicationSuccess,
+  updateTaskStatus,
+  validateProviderConfig,
+  wrapProviderError
+};