@astralform/js 0.1.0

package/dist/index.js

@@ -0,0 +1,967 @@
+// src/errors.ts
+var AstralformError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "AstralformError";
+  }
+};
+var AuthenticationError = class extends AstralformError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, "authentication_error");
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends AstralformError {
+  constructor(message = "Rate limit exceeded") {
+    super(message, "rate_limit_error");
+    this.name = "RateLimitError";
+  }
+};
+var LLMNotConfiguredError = class extends AstralformError {
+  constructor(message = "LLM provider not configured for this project") {
+    super(message, "llm_not_configured");
+    this.name = "LLMNotConfiguredError";
+  }
+};
+var ServerError = class extends AstralformError {
+  constructor(message = "Internal server error") {
+    super(message, "server_error");
+    this.name = "ServerError";
+  }
+};
+var ConnectionError = class extends AstralformError {
+  constructor(message = "Failed to connect to server") {
+    super(message, "connection_error");
+    this.name = "ConnectionError";
+  }
+};
+var StreamAbortedError = class extends AstralformError {
+  constructor(message = "Stream was aborted") {
+    super(message, "stream_aborted");
+    this.name = "StreamAbortedError";
+  }
+};
+
+// src/streaming.ts
+async function* streamJobSSE(options) {
+  const { url, headers, signal, fetchFn } = options;
+  let response;
+  try {
+    response = await fetchFn(url, {
+      method: "GET",
+      headers,
+      signal
+    });
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "AbortError") {
+      throw new StreamAbortedError();
+    }
+    throw new ConnectionError(
+      err instanceof Error ? err.message : "Failed to connect"
+    );
+  }
+  if (!response.ok) {
+    const rawText = await response.text().catch(() => "");
+    const text = rawText ? rawText.slice(0, 500).replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]") : "";
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError();
+      case 429:
+        throw new RateLimitError();
+      default:
+        throw new ServerError(text || `HTTP ${response.status}`);
+    }
+  }
+  if (!response.body) {
+    throw new ConnectionError("Response body is null");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent = "";
+  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) {
+        if (line.startsWith("event: ")) {
+          currentEvent = line.slice(7).trim();
+        } else if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") {
+            return;
+          }
+          yield { event: currentEvent || "message", data };
+        }
+        if (line === "") {
+          currentEvent = "";
+        }
+      }
+    }
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "AbortError") {
+      throw new StreamAbortedError();
+    }
+    throw err;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.astralform.ai";
+function validateBaseURL(url) {
+  const cleaned = url.replace(/\/+$/, "");
+  try {
+    const parsed = new URL(cleaned);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+      throw new Error(
+        `Invalid baseURL protocol "${parsed.protocol}" - only http: and https: are allowed`
+      );
+    }
+    return parsed.origin + parsed.pathname.replace(/\/+$/, "");
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Invalid baseURL")) {
+      throw err;
+    }
+    throw new Error(`Invalid baseURL: "${cleaned}" is not a valid URL`);
+  }
+}
+var AstralformClient = class {
+  constructor(config) {
+    if (!config.apiKey || typeof config.apiKey !== "string") {
+      throw new Error("apiKey is required and must be a non-empty string");
+    }
+    this.apiKey = config.apiKey;
+    this.baseURL = validateBaseURL(config.baseURL ?? DEFAULT_BASE_URL);
+    this.userId = config.userId;
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      "X-End-User-ID": this.userId,
+      "Content-Type": "application/json"
+    };
+  }
+  async request(method, path, body) {
+    const response = await this.fetchFn(`${this.baseURL}${path}`, {
+      method,
+      headers: this.headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    }).catch((err) => {
+      throw new ConnectionError(
+        err instanceof Error ? err.message : "Failed to connect"
+      );
+    });
+    await this.handleError(response);
+    return response;
+  }
+  async get(path) {
+    const response = await this.request("GET", path);
+    return response.json();
+  }
+  async post(path, body) {
+    const response = await this.request("POST", path, body);
+    return response.json();
+  }
+  async del(path) {
+    await this.request("DELETE", path);
+  }
+  async handleError(response) {
+    if (response.ok) return;
+    const text = await response.text().catch(() => "");
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError();
+      case 429:
+        throw new RateLimitError();
+      default: {
+        const safeText = text ? text.slice(0, 500).replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]") : "";
+        throw new ServerError(safeText || `HTTP ${response.status}`);
+      }
+    }
+  }
+  // --- REST Methods ---
+  async getHealth() {
+    return this.get("/v1/health");
+  }
+  async getProjectStatus() {
+    const raw = await this.get("/v1/project/status");
+    return {
+      isReady: raw.is_ready,
+      llmConfigured: raw.llm_configured,
+      llmProvider: raw.llm_provider,
+      llmModel: raw.llm_model,
+      message: raw.message
+    };
+  }
+  async getConversations(limit = 50, offset = 0) {
+    const safeLimit = Math.max(1, Math.min(200, Math.floor(Number(limit))));
+    const safeOffset = Math.max(0, Math.floor(Number(offset)));
+    const raw = await this.get(`/v1/conversations?limit=${safeLimit}&offset=${safeOffset}`);
+    return raw.map((c) => ({
+      id: c.id,
+      title: c.title,
+      messageCount: c.message_count,
+      createdAt: c.created_at,
+      updatedAt: c.updated_at
+    }));
+  }
+  async getMessages(conversationId) {
+    const raw = await this.get(`/v1/conversations/${encodeURIComponent(conversationId)}/messages`);
+    return raw.map((m) => ({
+      id: m.id,
+      conversationId: m.conversation_id,
+      role: m.role,
+      content: m.content,
+      parentId: m.parent_id,
+      status: "complete",
+      createdAt: m.created_at
+    }));
+  }
+  async deleteConversation(id) {
+    await this.del(`/v1/conversations/${encodeURIComponent(id)}`);
+  }
+  async getAgents() {
+    const raw = await this.get("/v1/agents");
+    return raw.map((a) => ({
+      name: a.name,
+      displayName: a.display_name,
+      description: a.description,
+      isOrchestrator: a.is_orchestrator,
+      isEnabled: a.is_enabled,
+      avatarUrl: a.avatar_url
+    }));
+  }
+  async getSkills() {
+    const raw = await this.get("/v1/skills");
+    return raw.map((s) => ({
+      name: s.name,
+      displayName: s.display_name,
+      description: s.description,
+      isEnabled: s.is_enabled
+    }));
+  }
+  async submitToolResult(request) {
+    await this.post("/v1/tool-result", request);
+  }
+  // --- Conversation Assets ---
+  mapAsset(raw) {
+    return {
+      id: raw.id,
+      kind: raw.kind,
+      originalName: raw.original_name,
+      mediaType: raw.media_type,
+      sizeBytes: raw.size_bytes,
+      workspacePath: raw.workspace_path,
+      sourceMessageId: raw.source_message_id,
+      agentName: raw.agent_name,
+      createdAt: raw.created_at
+    };
+  }
+  async uploadFile(conversationId, file, filename) {
+    const formData = new FormData();
+    formData.append("file", file, filename);
+    const response = await this.fetchFn(
+      `${this.baseURL}/v1/conversations/${encodeURIComponent(conversationId)}/uploads`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "X-End-User-ID": this.userId
+        },
+        body: formData
+      }
+    ).catch((err) => {
+      throw new ConnectionError(
+        err instanceof Error ? err.message : "Failed to connect"
+      );
+    });
+    await this.handleError(response);
+    const raw = await response.json();
+    return this.mapAsset(raw);
+  }
+  async listUploads(conversationId) {
+    const raw = await this.get(
+      `/v1/conversations/${encodeURIComponent(conversationId)}/uploads`
+    );
+    return raw.map((r) => this.mapAsset(r));
+  }
+  async listOutputs(conversationId) {
+    const raw = await this.get(
+      `/v1/conversations/${encodeURIComponent(conversationId)}/outputs`
+    );
+    return raw.map((r) => this.mapAsset(r));
+  }
+  // --- Jobs API ---
+  async createJob(request) {
+    return this.post("/v1/jobs", request);
+  }
+  async *streamJobEvents(jobId, afterSeq = -1, signal) {
+    const url = `${this.baseURL}/v1/jobs/${encodeURIComponent(jobId)}/events?after=${afterSeq}`;
+    yield* streamJobSSE({
+      url,
+      headers: this.headers,
+      signal,
+      fetchFn: this.fetchFn
+    });
+  }
+  async cancelJob(jobId) {
+    await this.post(`/v1/jobs/${encodeURIComponent(jobId)}/cancel`, {});
+  }
+};
+
+// src/storage.ts
+var InMemoryStorage = class {
+  constructor() {
+    this.conversations = /* @__PURE__ */ new Map();
+    this.messages = /* @__PURE__ */ new Map();
+  }
+  async fetchConversations() {
+    return Array.from(this.conversations.values()).sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+  }
+  async fetchConversation(id) {
+    return this.conversations.get(id) ?? null;
+  }
+  async createConversation(id, title) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const conversation = {
+      id,
+      title,
+      messageCount: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.conversations.set(id, conversation);
+    this.messages.set(id, []);
+    return conversation;
+  }
+  async updateConversationTitle(id, title) {
+    const conv = this.conversations.get(id);
+    if (conv) {
+      conv.title = title;
+      conv.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  async deleteConversation(id) {
+    this.conversations.delete(id);
+    this.messages.delete(id);
+  }
+  async fetchMessages(conversationId) {
+    return this.messages.get(conversationId) ?? [];
+  }
+  async addMessage(message, conversationId) {
+    const msgs = this.messages.get(conversationId) ?? [];
+    msgs.push(message);
+    this.messages.set(conversationId, msgs);
+    const conv = this.conversations.get(conversationId);
+    if (conv) {
+      conv.messageCount = msgs.length;
+      conv.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  async updateMessageStatus(id, status) {
+    for (const msgs of this.messages.values()) {
+      const msg = msgs.find((m) => m.id === id);
+      if (msg) {
+        msg.status = status;
+        return;
+      }
+    }
+  }
+  async deleteMessage(id) {
+    for (const [convId, msgs] of this.messages.entries()) {
+      const idx = msgs.findIndex((m) => m.id === id);
+      if (idx !== -1) {
+        msgs.splice(idx, 1);
+        const conv = this.conversations.get(convId);
+        if (conv) {
+          conv.messageCount = msgs.length;
+        }
+        return;
+      }
+    }
+  }
+};
+
+// src/tools.ts
+var TOOL_NAME_PATTERN = /^[a-zA-Z0-9_.\-]+$/;
+function sanitizeArgs(args) {
+  const clean = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(args)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      continue;
+    }
+    clean[key] = args[key];
+  }
+  return clean;
+}
+var ToolRegistry = class {
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+  }
+  registerTool(name, description, inputSchema, handler) {
+    if (!name || !TOOL_NAME_PATTERN.test(name)) {
+      throw new Error(
+        `Invalid tool name "${name}" - must match ${TOOL_NAME_PATTERN}`
+      );
+    }
+    if (name.length > 256) {
+      throw new Error("Tool name must be 256 characters or fewer");
+    }
+    this.tools.set(name, { name, description, inputSchema, handler });
+  }
+  unregisterTool(name) {
+    return this.tools.delete(name);
+  }
+  hasTool(name) {
+    return this.tools.has(name);
+  }
+  async executeTool(request) {
+    const tool = this.tools.get(request.toolName);
+    if (!tool) {
+      return {
+        call_id: request.callId,
+        tool_name: request.toolName,
+        result: `Tool "${request.toolName}" not found`,
+        is_error: true
+      };
+    }
+    try {
+      const result = await tool.handler(sanitizeArgs(request.arguments));
+      return {
+        call_id: request.callId,
+        tool_name: request.toolName,
+        result,
+        is_error: false
+      };
+    } catch (err) {
+      return {
+        call_id: request.callId,
+        tool_name: request.toolName,
+        result: err instanceof Error ? err.message : String(err),
+        is_error: true
+      };
+    }
+  }
+  getManifest() {
+    return Array.from(this.tools.values()).map((t) => ({
+      name: t.name,
+      description: t.description,
+      parameters: t.inputSchema
+    }));
+  }
+  getToolNames() {
+    return Array.from(this.tools.keys());
+  }
+  clear() {
+    this.tools.clear();
+  }
+};
+
+// src/utils.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/session.ts
+var ChatSession = class {
+  constructor(config, storage) {
+    // State
+    this.conversationId = null;
+    this.conversations = [];
+    this.messages = [];
+    this.streamingContent = "";
+    this.isStreaming = false;
+    this.executingTool = null;
+    this.projectStatus = null;
+    this.agents = [];
+    this.skills = [];
+    this.enabledClientTools = /* @__PURE__ */ new Set();
+    this.modelDisplayName = null;
+    // New state fields
+    this.thinkingContent = "";
+    this.isThinking = false;
+    this.activeSubagents = /* @__PURE__ */ new Map();
+    this.sources = [];
+    this.capsuleOutputs = [];
+    this.todos = [];
+    this.activeTools = /* @__PURE__ */ new Map();
+    this.handlers = /* @__PURE__ */ new Set();
+    this.abortController = null;
+    /** Last received sequence number for resumable reconnection */
+    this.lastSeq = -1;
+    /** Current job ID for cancellation */
+    this.currentJobId = null;
+    this.client = new AstralformClient(config);
+    this.toolRegistry = new ToolRegistry();
+    this.storage = storage ?? new InMemoryStorage();
+  }
+  on(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  emit(event) {
+    for (const handler of this.handlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  async connect() {
+    const [status, conversations, agents, skills] = await Promise.allSettled([
+      this.client.getProjectStatus(),
+      this.client.getConversations(),
+      this.client.getAgents().catch(() => []),
+      this.client.getSkills().catch(() => [])
+    ]);
+    if (status.status === "fulfilled") {
+      this.projectStatus = status.value;
+    }
+    if (conversations.status === "fulfilled") {
+      this.conversations = conversations.value;
+    }
+    if (agents.status === "fulfilled") {
+      this.agents = agents.value;
+    }
+    if (skills.status === "fulfilled") {
+      this.skills = skills.value;
+    }
+    this.emit({ type: "connected" });
+  }
+  async send(content, options) {
+    if (this.isStreaming) return;
+    const conversationId = options?.conversationId ?? this.conversationId ?? void 0;
+    const userMessage = {
+      id: generateId(),
+      conversationId: conversationId ?? "",
+      role: "user",
+      content,
+      status: "complete",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (conversationId) {
+      await this.storage.addMessage(userMessage, conversationId);
+    }
+    this.messages.push(userMessage);
+    const request = {
+      message: content,
+      conversation_id: conversationId,
+      mcp_manifest: this.toolRegistry.getManifest(),
+      enabled_mcp: Array.from(
+        options?.enabledClientTools ?? this.enabledClientTools
+      ),
+      upload_ids: options?.uploadIds,
+      agent_name: options?.agentName
+    };
+    await this.processStream(request);
+  }
+  async resendFromCheckpoint(messageId, newContent) {
+    if (this.isStreaming) return;
+    const request = {
+      message: newContent,
+      conversation_id: this.conversationId ?? void 0,
+      resend_from: messageId,
+      mcp_manifest: this.toolRegistry.getManifest(),
+      enabled_mcp: Array.from(this.enabledClientTools)
+    };
+    await this.processStream(request);
+  }
+  async processStream(request) {
+    this.isStreaming = true;
+    this.streamingContent = "";
+    this.thinkingContent = "";
+    this.isThinking = false;
+    this.activeSubagents.clear();
+    this.sources = [];
+    this.capsuleOutputs = [];
+    this.todos = [];
+    this.activeTools.clear();
+    this.abortController = new AbortController();
+    try {
+      await this.consumeJobStream(request);
+    } catch (err) {
+      this.emit({
+        type: "error",
+        error: err instanceof Error ? err : new ConnectionError(String(err))
+      });
+    } finally {
+      this.isStreaming = false;
+      this.executingTool = null;
+      this.abortController = null;
+    }
+  }
+  async consumeJobStream(request) {
+    const job = await this.client.createJob(request);
+    this.currentJobId = job.job_id;
+    let conversationId = job.conversation_id;
+    if (!this.conversationId) {
+      this.conversationId = conversationId;
+    }
+    const messageId = job.message_id;
+    this.lastSeq = -1;
+    let stopTitle;
+    const stream = this.client.streamJobEvents(
+      job.job_id,
+      this.lastSeq,
+      this.abortController?.signal
+    );
+    for await (const raw of stream) {
+      let parsed;
+      try {
+        const data = JSON.parse(raw.data);
+        if (typeof data !== "object" || data === null || typeof data.type !== "string") {
+          if (typeof data?.seq === "number") {
+            this.lastSeq = data.seq;
+          }
+          continue;
+        }
+        parsed = data;
+        if (typeof data.seq === "number") {
+          this.lastSeq = data.seq;
+        }
+      } catch {
+        continue;
+      }
+      switch (parsed.type) {
+        case "message_start":
+          conversationId = parsed.conversation_id;
+          if (!this.conversationId) {
+            this.conversationId = conversationId;
+          }
+          if (parsed.model_display_name) {
+            this.modelDisplayName = parsed.model_display_name;
+            this.emit({
+              type: "model_info",
+              name: parsed.model_display_name
+            });
+          }
+          if (parsed.agent_name) {
+            this.emit({
+              type: "agent_start",
+              agentName: parsed.agent_name,
+              agentDisplayName: parsed.agent_display_name
+            });
+          }
+          break;
+        case "content_block_delta":
+          this.streamingContent += parsed.delta.text;
+          this.emit({ type: "chunk", text: parsed.delta.text });
+          break;
+        case "tool_use_start": {
+          const toolCall = {
+            callId: parsed.call_id,
+            toolName: parsed.tool,
+            displayName: parsed.display_name,
+            description: parsed.description,
+            arguments: parsed.arguments,
+            isClientTool: parsed.is_client_tool
+          };
+          this.activeTools.set(parsed.call_id, {
+            toolName: parsed.tool,
+            displayName: parsed.display_name,
+            description: parsed.description,
+            arguments: parsed.arguments,
+            callId: parsed.call_id,
+            status: parsed.is_client_tool ? "calling" : "executing",
+            isClientTool: parsed.is_client_tool
+          });
+          this.emit({ type: "tool_call", request: toolCall });
+          if (parsed.is_client_tool) {
+            const results = await this.executeClientTools([toolCall]);
+            await this.client.submitToolResult({
+              conversation_id: conversationId,
+              message_id: messageId,
+              tool_results: results
+            });
+          }
+          break;
+        }
+        case "tool_use_end": {
+          const toolState = this.activeTools.get(parsed.call_id);
+          if (toolState) {
+            toolState.status = "completed";
+          }
+          this.emit({
+            type: "tool_end",
+            callId: parsed.call_id,
+            toolName: parsed.tool
+          });
+          break;
+        }
+        case "agent_start":
+          this.emit({
+            type: "agent_start",
+            agentName: parsed.agent_name,
+            agentDisplayName: parsed.agent_display_name,
+            avatarUrl: parsed.avatar_url
+          });
+          break;
+        case "agent_end":
+          this.emit({ type: "agent_end", agentName: parsed.agent_name });
+          break;
+        case "subagent_start":
+          this.activeSubagents.set(parsed.tool_call_id, {
+            agentName: parsed.agent_name,
+            displayName: parsed.display_name,
+            avatarUrl: parsed.avatar_url,
+            description: parsed.description,
+            content: "",
+            isActive: true
+          });
+          this.emit({
+            type: "subagent_start",
+            agentName: parsed.agent_name,
+            displayName: parsed.display_name,
+            toolCallId: parsed.tool_call_id,
+            avatarUrl: parsed.avatar_url,
+            description: parsed.description
+          });
+          break;
+        case "subagent_update": {
+          const sub = this.activeSubagents.get(parsed.tool_call_id);
+          if (sub) {
+            sub.agentName = parsed.agent_name;
+            sub.displayName = parsed.display_name;
+          }
+          this.emit({
+            type: "subagent_update",
+            agentName: parsed.agent_name,
+            displayName: parsed.display_name,
+            toolCallId: parsed.tool_call_id
+          });
+          break;
+        }
+        case "subagent_content_delta": {
+          const subagent = this.activeSubagents.get(parsed.tool_call_id);
+          if (subagent) {
+            subagent.content += parsed.delta.text;
+          }
+          this.emit({
+            type: "subagent_chunk",
+            agentName: parsed.agent_name,
+            toolCallId: parsed.tool_call_id,
+            text: parsed.delta.text
+          });
+          break;
+        }
+        case "subagent_end": {
+          const sub = this.activeSubagents.get(parsed.tool_call_id);
+          if (sub) {
+            sub.isActive = false;
+          }
+          this.emit({
+            type: "subagent_end",
+            agentName: parsed.agent_name,
+            displayName: parsed.display_name,
+            toolCallId: parsed.tool_call_id
+          });
+          break;
+        }
+        case "thinking_delta":
+          this.thinkingContent += parsed.delta.text;
+          this.isThinking = true;
+          this.emit({ type: "thinking_delta", text: parsed.delta.text });
+          break;
+        case "thinking_complete":
+          this.isThinking = false;
+          this.emit({ type: "thinking_complete" });
+          break;
+        case "sources":
+          this.sources.push(...parsed.sources);
+          this.emit({ type: "sources", sources: parsed.sources });
+          break;
+        case "capsule_output": {
+          const capsule = {
+            toolName: parsed.tool_name,
+            agentName: parsed.agent_name,
+            command: parsed.command,
+            output: parsed.output,
+            durationMs: parsed.duration_ms
+          };
+          this.capsuleOutputs.push(capsule);
+          this.emit({ type: "capsule_output", ...capsule });
+          break;
+        }
+        case "todo_update":
+          this.todos = parsed.todos;
+          this.emit({ type: "todo_update", todos: parsed.todos });
+          break;
+        case "subagent_tool_use":
+          this.emit({
+            type: "subagent_tool_use",
+            agentName: parsed.agent_name,
+            toolName: parsed.tool,
+            toolCallId: parsed.tool_call_id,
+            result: parsed.result
+          });
+          break;
+        case "asset_created":
+          this.emit({
+            type: "asset_created",
+            assetId: parsed.asset_id,
+            name: parsed.name,
+            url: parsed.url,
+            mediaType: parsed.media_type,
+            sizeBytes: parsed.size_bytes
+          });
+          break;
+        case "retry":
+          this.emit({
+            type: "retry",
+            attempt: parsed.attempt,
+            maxAttempts: parsed.max_attempts,
+            delaySeconds: parsed.delay_seconds
+          });
+          break;
+        case "message_stop":
+          stopTitle = parsed.title;
+          break;
+        case "error":
+          this.emit({
+            type: "error",
+            error: new AstralformError(parsed.message, parsed.code)
+          });
+          break;
+      }
+    }
+    this.currentJobId = null;
+    await this.completeStream(conversationId, messageId, stopTitle);
+  }
+  async executeClientTools(toolCalls) {
+    const results = [];
+    for (const call of toolCalls) {
+      this.executingTool = call.toolName;
+      const toolState = this.activeTools.get(call.callId);
+      if (toolState) {
+        toolState.status = "executing";
+      }
+      this.emit({ type: "tool_executing", name: call.toolName });
+      const result = await this.toolRegistry.executeTool(call);
+      results.push(result);
+      if (toolState) {
+        toolState.status = "completed";
+      }
+      this.emit({
+        type: "tool_completed",
+        name: call.toolName,
+        result: result.result
+      });
+    }
+    this.executingTool = null;
+    return results;
+  }
+  async completeStream(conversationId, messageId, title) {
+    const assistantMessage = {
+      id: messageId || generateId(),
+      conversationId,
+      role: "assistant",
+      content: this.streamingContent,
+      status: "complete",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.messages.push(assistantMessage);
+    await this.storage.addMessage(assistantMessage, conversationId);
+    if (title && conversationId) {
+      await this.storage.updateConversationTitle(conversationId, title);
+      const conv = this.conversations.find((c) => c.id === conversationId);
+      if (conv) {
+        conv.title = title;
+      }
+    }
+    this.emit({
+      type: "complete",
+      content: this.streamingContent,
+      conversationId,
+      messageId: assistantMessage.id,
+      title
+    });
+  }
+  disconnect() {
+    if (this.currentJobId) {
+      this.client.cancelJob(this.currentJobId).catch(() => {
+      });
+      this.currentJobId = null;
+    }
+    this.abortController?.abort();
+    this.abortController = null;
+    this.isStreaming = false;
+    this.streamingContent = "";
+    this.executingTool = null;
+    this.emit({ type: "disconnected" });
+  }
+  async createNewConversation() {
+    const id = generateId();
+    const conversation = await this.storage.createConversation(
+      id,
+      "New Conversation"
+    );
+    this.conversations.unshift(conversation);
+    this.conversationId = id;
+    this.messages = [];
+    this.streamingContent = "";
+    return id;
+  }
+  async switchConversation(id) {
+    this.conversationId = id;
+    try {
+      this.messages = await this.client.getMessages(id);
+    } catch {
+      this.messages = await this.storage.fetchMessages(id);
+    }
+    this.streamingContent = "";
+  }
+  async deleteConversation(id) {
+    try {
+      await this.client.deleteConversation(id);
+    } catch {
+    }
+    await this.storage.deleteConversation(id);
+    this.conversations = this.conversations.filter((c) => c.id !== id);
+    if (this.conversationId === id) {
+      this.conversationId = null;
+      this.messages = [];
+    }
+  }
+  toggleClientTool(name) {
+    if (this.enabledClientTools.has(name)) {
+      this.enabledClientTools.delete(name);
+      return false;
+    }
+    this.enabledClientTools.add(name);
+    return true;
+  }
+};
+export {
+  AstralformClient,
+  AstralformError,
+  AuthenticationError,
+  ChatSession,
+  ConnectionError,
+  InMemoryStorage,
+  LLMNotConfiguredError,
+  RateLimitError,
+  ServerError,
+  StreamAbortedError,
+  ToolRegistry,
+  generateId,
+  streamJobSSE
+};
+//# sourceMappingURL=index.js.map