@astralform/js 0.2.0 → 0.2.2

package/dist/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   AstralformError: () => AstralformError,
   AuthenticationError: () => AuthenticationError,
   BlockBuilder: () => BlockBuilder,
+  ChatEventType: () => ChatEventType,
   ChatSession: () => ChatSession,
   ConnectionError: () => ConnectionError,
   InMemoryStorage: () => InMemoryStorage,
@@ -31,6 +32,7 @@ __export(index_exports, {
   RateLimitError: () => RateLimitError,
   ServerError: () => ServerError,
   StreamAbortedError: () => StreamAbortedError,
+  StreamManager: () => StreamManager,
   ToolRegistry: () => ToolRegistry,
   generateId: () => generateId,
   standardHandlers: () => standardHandlers,
@@ -287,10 +289,10 @@ var AstralformClient = class {
       isEnabled: s.is_enabled
     }));
   }
-  async getConversationEvents(conversationId) {
-    return this.get(
-      `/v1/conversations/${encodeURIComponent(conversationId)}/events`
-    );
+  async getConversationEvents(conversationId, jobId) {
+    let url = `/v1/conversations/${encodeURIComponent(conversationId)}/events`;
+    if (jobId) url += `?job_id=${encodeURIComponent(jobId)}`;
+    return this.get(url);
   }
   async submitToolResult(request) {
     await this.post("/v1/tool-result", request);
@@ -372,6 +374,8 @@ var BlockBuilder = class {
     this.activeTextId = null;
     this.activeThinkingId = null;
     this.thinkingStartMs = null;
+    this.activeEditorId = null;
+    this.activeTodoId = null;
   }
   // ── Registration ──────────────────────────────────────────────
   on(eventType, handler) {
@@ -398,6 +402,8 @@ var BlockBuilder = class {
     this.activeTextId = null;
     this.activeThinkingId = null;
     this.thinkingStartMs = null;
+    this.activeEditorId = null;
+    this.activeTodoId = null;
   }
   setOnChange(fn) {
     this._onChange = fn;
@@ -623,7 +629,6 @@ var ChatSession = class {
     this.thinkingContent = "";
     this.isThinking = false;
     this.activeSubagents = /* @__PURE__ */ new Map();
-    this.sources = [];
     this.capsuleOutputs = [];
     this.todos = [];
     this.activeTools = /* @__PURE__ */ new Map();
@@ -727,7 +732,6 @@ var ChatSession = class {
     this.thinkingContent = "";
     this.isThinking = false;
     this.activeSubagents.clear();
-    this.sources = [];
     this.capsuleOutputs = [];
     this.todos = [];
     this.activeTools.clear();
@@ -739,10 +743,12 @@ var ChatSession = class {
     try {
       await this.consumeJobStream(request);
     } catch (err) {
-      this.emit({
-        type: "error",
-        error: err instanceof Error ? err : new ConnectionError(String(err))
-      });
+      if (!(err instanceof DOMException && err.name === "AbortError")) {
+        this.emit({
+          type: "error",
+          error: err instanceof Error ? err : new ConnectionError(String(err))
+        });
+      }
     } finally {
       this.isStreaming = false;
       this.executingTool = null;
@@ -895,11 +901,24 @@ var ChatSession = class {
   applyEvent(event) {
     switch (event.type) {
       case "user_message":
-        this.emit({ type: "user_message", content: event.content });
+        this.emit({
+          type: "user_message",
+          content: event.content,
+          createdAt: event.created_at
+        });
         break;
-      case "title_generated":
+      case "title_generated": {
+        if (this.conversationId && event.title) {
+          const conv = this.conversations.find(
+            (c) => c.id === this.conversationId
+          );
+          if (conv) {
+            conv.title = event.title;
+          }
+        }
         this.emit({ type: "title_generated", title: event.title });
         break;
+      }
       case "message_start":
         if (event.conversation_id && !this.conversationId) {
           this.conversationId = event.conversation_id;
@@ -922,6 +941,23 @@ var ChatSession = class {
         this.isThinking = false;
         this.emit({ type: "thinking_complete" });
         break;
+      case "tool_executing":
+        this.emit({
+          type: "tool_executing",
+          name: event.tool,
+          call_id: event.call_id
+        });
+        break;
+      case "tool_progress":
+        this.emit({
+          type: "tool_progress",
+          callId: event.call_id,
+          tool: event.tool,
+          index: event.index,
+          total: event.total,
+          item: event.item
+        });
+        break;
       case "message_stop":
         this.emit({
           type: "complete",
@@ -1031,10 +1067,6 @@ var ChatSession = class {
           result: event.result
         });
         break;
-      case "sources":
-        this.sources.push(...event.sources);
-        this.emit({ type: "sources", sources: event.sources });
-        break;
       case "capsule_output": {
         const capsule = {
           toolName: event.tool_name,
@@ -1070,27 +1102,6 @@ var ChatSession = class {
           sizeBytes: event.size_bytes
         });
         break;
-      case "timeline_entry":
-        this.emit({
-          type: "timeline_entry",
-          id: event.id,
-          status: event.status,
-          kind: event.kind,
-          agent_name: event.agent_name,
-          tool_name: event.tool_name,
-          display_name: event.display_name,
-          tool_category: event.tool_category,
-          viewer: event.viewer,
-          call_id: event.call_id,
-          detail: event.detail,
-          started_at: event.started_at,
-          duration_ms: event.duration_ms,
-          output_summary: event.output_summary,
-          sources: event.sources,
-          parent_id: event.parent_id,
-          structured_output: event.structured_output
-        });
-        break;
       case "editor_content_start":
         this.emit({
           type: "editor_content_start",
@@ -1212,19 +1223,26 @@ var ChatSession = class {
       this.abortController = null;
     }
   }
-  disconnect() {
-    if (this.currentJobId) {
-      this.client.cancelJob(this.currentJobId).catch(() => {
-      });
-      this.currentJobId = null;
-    }
+  /** Detach from the SSE stream without cancelling the job.
+   *  The backend job keeps running — caller can reconnect later. */
+  detach() {
     this.abortController?.abort();
     this.abortController = null;
     this.isStreaming = false;
     this.streamingContent = "";
     this.executingTool = null;
+    this.blockBuilder.reset();
     this.emit({ type: "disconnected" });
   }
+  /** Stop the job and disconnect (explicit user action). */
+  disconnect() {
+    if (this.currentJobId) {
+      this.client.cancelJob(this.currentJobId).catch(() => {
+      });
+    }
+    this.detach();
+    this.currentJobId = null;
+  }
   async createNewConversation() {
     const id = generateId();
     const conversation = await this.storage.createConversation(
@@ -1237,13 +1255,13 @@ var ChatSession = class {
     this.streamingContent = "";
     return id;
   }
-  async switchConversation(id) {
+  async switchConversation(id, jobId) {
     this.conversationId = id;
     this.resetStreamingState();
     this.blockBuilder.reset();
     const [messagesResult, eventsResult] = await Promise.allSettled([
       this.client.getMessages(id).catch(() => this.storage.fetchMessages(id)),
-      this.client.getConversationEvents(id)
+      this.client.getConversationEvents(id, jobId)
     ]);
     this.messages = messagesResult.status === "fulfilled" ? messagesResult.value : [];
     if (eventsResult.status === "fulfilled") {
@@ -1292,10 +1310,31 @@ function finalizeThinking(builder) {
     builder.thinkingStartMs = null;
   }
 }
+function finalizeEditor(builder) {
+  if (builder.activeEditorId) {
+    builder.patchBlock(builder.activeEditorId, {
+      isStreaming: false
+    });
+    builder.activeEditorId = null;
+  }
+}
 var handleUserMessage = (event, builder) => {
-  if (builder.findBlock((b) => b.type === "user")) return;
   const e = event;
-  builder.addBlock({ type: "user", id: builder.nextId(), content: e.content });
+  const existing = builder.findBlock((b) => b.type === "user");
+  if (existing) {
+    if (e.createdAt) {
+      builder.patchBlock(existing.id, {
+        createdAt: e.createdAt
+      });
+    }
+    return;
+  }
+  builder.addBlock({
+    type: "user",
+    id: builder.nextId(),
+    content: e.content,
+    createdAt: e.createdAt
+  });
 };
 var handleChunk = (event, builder) => {
   const e = event;
@@ -1337,12 +1376,26 @@ var handleToolCall = (event, builder) => {
 var handleToolExecuting = (event, builder) => {
   const e = event;
   const block = builder.findBlock(
-    (b) => b.type === "tool" && b.toolName === e.name && b.status === "calling"
+    (b) => b.type === "tool" && (e.call_id ? b.callId === e.call_id : b.toolName === e.name) && b.status === "calling"
   );
   if (block) {
     builder.patchBlock(block.id, { status: "executing" });
   }
 };
+var handleToolProgress = (event, builder) => {
+  const e = event;
+  const block = builder.findBlock(
+    (b) => b.type === "tool" && b.callId === e.callId
+  );
+  if (block && block.type === "tool") {
+    const sources = block.sources ? [...block.sources] : [];
+    sources.push(e.item);
+    builder.patchBlock(block.id, {
+      sources,
+      status: "executing"
+    });
+  }
+};
 var handleToolEnd = (event, builder) => {
   const e = event;
   const callId = e.type === "tool_end" ? e.callId : void 0;
@@ -1455,6 +1508,7 @@ var handleSubagentEnd = (event, builder) => {
 var handleComplete = (_event, builder) => {
   finalizeText(builder);
   finalizeThinking(builder);
+  finalizeEditor(builder);
   for (const b of builder.getBlocks()) {
     if (b.type === "tool" && b.status !== "completed") {
       builder.patchBlock(b.id, { status: "completed" });
@@ -1474,31 +1528,422 @@ var handleError = (event, builder) => {
 var handleDisconnected = (_event, builder) => {
   finalizeText(builder);
   finalizeThinking(builder);
+  finalizeEditor(builder);
+};
+var handleCapsuleOutputChunk = (event, builder) => {
+  const e = event;
+  const block = builder.findBlock(
+    (b) => b.type === "capsule" && b.callId === e.callId
+  );
+  if (block && block.type === "capsule") {
+    builder.patchBlock(block.id, {
+      output: block.output + e.chunk
+    });
+  } else {
+    builder.addBlock({
+      type: "capsule",
+      id: builder.nextId(),
+      callId: e.callId,
+      toolName: "",
+      output: e.chunk,
+      isActive: true
+    });
+  }
+};
+var handleCapsuleOutput = (event, builder) => {
+  const e = event;
+  const block = builder.findBlock(
+    (b) => b.type === "capsule" && b.callId === (e.callId ?? "")
+  );
+  if (block) {
+    builder.patchBlock(block.id, {
+      output: e.output,
+      command: e.command,
+      toolName: e.toolName,
+      durationMs: e.durationMs,
+      isActive: false
+    });
+  } else {
+    builder.addBlock({
+      type: "capsule",
+      id: builder.nextId(),
+      callId: e.callId ?? "",
+      toolName: e.toolName,
+      command: e.command,
+      output: e.output,
+      durationMs: e.durationMs,
+      isActive: false
+    });
+  }
+};
+var handleAssetCreated = (event, builder) => {
+  const e = event;
+  builder.addBlock({
+    type: "asset",
+    id: builder.nextId(),
+    assetId: e.assetId,
+    name: e.name,
+    url: e.url,
+    mediaType: e.mediaType,
+    sizeBytes: e.sizeBytes
+  });
+};
+var handleTodoUpdate = (event, builder) => {
+  const e = event;
+  if (builder.activeTodoId) {
+    builder.patchBlock(builder.activeTodoId, {
+      todos: e.todos
+    });
+  } else {
+    const id = builder.nextId();
+    builder.activeTodoId = id;
+    builder.addBlock({
+      type: "todo",
+      id,
+      todos: e.todos
+    });
+  }
+};
+var handleEditorContentStart = (event, builder) => {
+  const e = event;
+  const id = builder.nextId();
+  builder.activeEditorId = id;
+  builder.addBlock({
+    type: "editor",
+    id,
+    callId: e.callId,
+    path: e.path,
+    language: e.language,
+    content: "",
+    isStreaming: true
+  });
+};
+var handleEditorContentDelta = (event, builder) => {
+  const e = event;
+  const block = builder.findBlock(
+    (b) => b.type === "editor" && b.callId === e.callId
+  );
+  if (block && block.type === "editor") {
+    builder.patchBlock(block.id, {
+      content: block.content + e.delta
+    });
+  }
+};
+var handleEditorContentEnd = (event, builder) => {
+  const e = event;
+  const block = builder.findBlock(
+    (b) => b.type === "editor" && b.callId === e.callId
+  );
+  if (block) {
+    builder.patchBlock(block.id, {
+      isStreaming: false
+    });
+  }
+  builder.activeEditorId = null;
+};
+var noop = () => {
 };
 var standardHandlers = {
   user_message: handleUserMessage,
   chunk: handleChunk,
   tool_call: handleToolCall,
   tool_executing: handleToolExecuting,
+  tool_progress: handleToolProgress,
   tool_completed: handleToolEnd,
   tool_end: handleToolEnd,
   agent_start: handleAgentStart,
+  agent_end: noop,
   thinking_delta: handleThinkingDelta,
   thinking_complete: handleThinkingComplete,
   subagent_start: handleSubagentStart,
   subagent_chunk: handleSubagentChunk,
   subagent_update: handleSubagentUpdate,
   subagent_end: handleSubagentEnd,
+  subagent_tool_use: noop,
+  capsule_output: handleCapsuleOutput,
+  capsule_output_chunk: handleCapsuleOutputChunk,
+  asset_created: handleAssetCreated,
+  todo_update: handleTodoUpdate,
+  editor_content_start: handleEditorContentStart,
+  editor_content_delta: handleEditorContentDelta,
+  editor_content_end: handleEditorContentEnd,
+  retry: noop,
   complete: handleComplete,
   error: handleError,
   disconnected: handleDisconnected
 };
+
+// src/types.ts
+var ChatEventType = {
+  Connected: "connected",
+  BlocksChanged: "blocks_changed",
+  UserMessage: "user_message",
+  TitleGenerated: "title_generated",
+  ModelInfo: "model_info",
+  Chunk: "chunk",
+  ToolCall: "tool_call",
+  ToolExecuting: "tool_executing",
+  ToolProgress: "tool_progress",
+  ToolCompleted: "tool_completed",
+  ToolEnd: "tool_end",
+  AgentStart: "agent_start",
+  AgentEnd: "agent_end",
+  ThinkingDelta: "thinking_delta",
+  ThinkingComplete: "thinking_complete",
+  SubagentStart: "subagent_start",
+  SubagentChunk: "subagent_chunk",
+  SubagentUpdate: "subagent_update",
+  SubagentEnd: "subagent_end",
+  SubagentToolUse: "subagent_tool_use",
+  CapsuleOutput: "capsule_output",
+  CapsuleOutputChunk: "capsule_output_chunk",
+  AssetCreated: "asset_created",
+  TodoUpdate: "todo_update",
+  EditorContentStart: "editor_content_start",
+  EditorContentDelta: "editor_content_delta",
+  EditorContentEnd: "editor_content_end",
+  Complete: "complete",
+  Error: "error",
+  Disconnected: "disconnected",
+  Retry: "retry"
+};
+
+// src/stream-manager.ts
+var StreamManager = class {
+  constructor(session) {
+    this._state = "idle";
+    this._activeConversationId = null;
+    this._backgroundJobs = /* @__PURE__ */ new Map();
+    this.handlers = [];
+    this.unsub = null;
+    this.session = session;
+    this.attach();
+  }
+  // ── Public state ──────────────────────────────────────────────
+  get state() {
+    return this._state;
+  }
+  get activeConversationId() {
+    return this._activeConversationId;
+  }
+  get backgroundJobs() {
+    return this._backgroundJobs;
+  }
+  // ── Event subscription ────────────────────────────────────────
+  on(handler) {
+    this.handlers.push(handler);
+    return () => {
+      this.handlers = this.handlers.filter((h) => h !== handler);
+    };
+  }
+  emit(event) {
+    for (const handler of this.handlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  setState(state) {
+    this._state = state;
+    this.emit({
+      type: "stateChange",
+      state,
+      conversationId: this._activeConversationId
+    });
+  }
+  // ── Session event wiring ──────────────────────────────────────
+  attach() {
+    this.unsub = this.session.on((event) => {
+      this.onSessionEvent(event);
+    });
+  }
+  onSessionEvent(event) {
+    const convId = this.session.conversationId;
+    if (event.type === ChatEventType.BlocksChanged) {
+      if (this._state === "streaming" && convId) {
+        this.emit({
+          type: "blocksChanged",
+          conversationId: convId,
+          blocks: event.blocks
+        });
+      }
+      return;
+    }
+    this.emit({
+      type: "event",
+      conversationId: convId,
+      event
+    });
+    if (event.type === ChatEventType.Complete) {
+      if (this._state === "streaming") {
+        this.setState("idle");
+      }
+    }
+  }
+  // ── Send ──────────────────────────────────────────────────────
+  async send(content, options) {
+    if (this._state === "streaming") return;
+    if (!this._activeConversationId) {
+      const id = await this.session.createNewConversation();
+      this.setActiveConversation(id);
+    }
+    this.prepareUserBlock(content);
+    this.setState("streaming");
+    try {
+      await this.session.send(content, {
+        enableSearch: options?.enableSearch,
+        agentName: options?.agentName,
+        uploadIds: options?.uploadIds
+      });
+    } catch {
+    }
+    this.finalizeStream();
+  }
+  // ── Regenerate ────────────────────────────────────────────────
+  async regenerate() {
+    if (this._state === "streaming") return;
+    const userMsgs = this.session.messages.filter(
+      (m) => m.role === "user"
+    );
+    const lastUserMsg = userMsgs[userMsgs.length - 1];
+    if (!lastUserMsg) return;
+    this.prepareUserBlock(lastUserMsg.content);
+    this.setState("streaming");
+    try {
+      await this.session.resendFromCheckpoint(
+        lastUserMsg.id,
+        lastUserMsg.content
+      );
+    } catch {
+    }
+    this.finalizeStream();
+  }
+  // ── Switch conversation ───────────────────────────────────────
+  async switchTo(conversationId) {
+    if (conversationId === this._activeConversationId) return;
+    if (this._state === "streaming") {
+      const oldConvId = this._activeConversationId;
+      const jobId = this.session.currentJobId;
+      if (oldConvId && jobId) {
+        this._backgroundJobs.set(oldConvId, jobId);
+        this.emit({
+          type: "backgroundJobsChanged",
+          jobs: this._backgroundJobs
+        });
+      }
+      this.session.detach();
+    }
+    if (this._backgroundJobs.has(conversationId)) {
+      this._backgroundJobs.delete(conversationId);
+      this.emit({
+        type: "backgroundJobsChanged",
+        jobs: this._backgroundJobs
+      });
+    }
+    this.setActiveConversation(conversationId);
+    await this.restore(conversationId);
+  }
+  // ── Create / delete conversation ──────────────────────────────
+  async createConversation() {
+    const id = await this.session.createNewConversation();
+    this.setActiveConversation(id);
+    return id;
+  }
+  async deleteConversation(id) {
+    await this.session.deleteConversation(id);
+    this._backgroundJobs.delete(id);
+    if (this._activeConversationId === id) {
+      this._activeConversationId = null;
+      this.emit({ type: "conversationChanged", conversationId: null });
+    }
+  }
+  // ── Stop (explicit cancel) ────────────────────────────────────
+  stop() {
+    this.session.disconnect();
+    this.setState("idle");
+  }
+  // ── Cleanup ───────────────────────────────────────────────────
+  destroy() {
+    if (this.unsub) {
+      this.unsub();
+      this.unsub = null;
+    }
+    this.handlers = [];
+  }
+  // ── Internal: helpers ──────────────────────────────────────────
+  prepareUserBlock(content) {
+    this.session.blockBuilder.reset();
+    this.session.blockBuilder.addBlock({
+      type: "user",
+      id: this.session.blockBuilder.nextId(),
+      content
+    });
+  }
+  finalizeStream() {
+    if (this._state === "streaming") {
+      this.setState("idle");
+    }
+  }
+  // ── Internal: restore ─────────────────────────────────────────
+  async restore(conversationId) {
+    this.setState("restoring");
+    let activeJobId = null;
+    try {
+      const res = await this.session.client.get(`/v1/conversations/${encodeURIComponent(conversationId)}/active-job`);
+      activeJobId = res.job_id ?? null;
+    } catch {
+    }
+    if (activeJobId) {
+      await this.session.loadConversation(conversationId);
+      this.setState("streaming");
+      try {
+        await this.session.reconnectToJob(activeJobId);
+      } catch {
+      }
+      if (this._state === "streaming") {
+        this.setState("idle");
+      }
+    } else {
+      await this.session.loadConversation(conversationId);
+      try {
+        const jobs = await this.session.client.get(`/v1/conversations/${encodeURIComponent(conversationId)}/jobs`);
+        const completedJobs = jobs.filter(
+          (j) => j.status === "completed"
+        );
+        for (const job of completedJobs) {
+          await this.session.switchConversation(conversationId, job.job_id);
+        }
+        if (completedJobs.length > 0) {
+          this.emit({
+            type: "blocksChanged",
+            conversationId,
+            blocks: this.session.blockBuilder.getBlocks()
+          });
+          this.emit({
+            type: "versionsReady",
+            conversationId,
+            count: completedJobs.length
+          });
+        }
+      } catch {
+      }
+      this.setState("idle");
+    }
+  }
+  // ── Internal: set active conversation ─────────────────────────
+  setActiveConversation(id) {
+    this._activeConversationId = id;
+    this.emit({ type: "conversationChanged", conversationId: id });
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AstralformClient,
   AstralformError,
   AuthenticationError,
   BlockBuilder,
+  ChatEventType,
   ChatSession,
   ConnectionError,
   InMemoryStorage,
@@ -1506,6 +1951,7 @@ var standardHandlers = {
   RateLimitError,
   ServerError,
   StreamAbortedError,
+  StreamManager,
   ToolRegistry,
   generateId,
   standardHandlers,