@astralform/js 0.1.2 → 0.2.0

package/dist/index.js

@@ -321,6 +321,87 @@ var AstralformClient = class {
   }
 };
 
+// src/block-builder.ts
+var _idCounter = 0;
+var BlockBuilder = class {
+  constructor() {
+    this._blocks = [];
+    this._handlers = /* @__PURE__ */ new Map();
+    this._onChange = null;
+    // Active block refs — public so handlers can read/write them
+    this.activeTextId = null;
+    this.activeThinkingId = null;
+    this.thinkingStartMs = null;
+  }
+  // ── Registration ──────────────────────────────────────────────
+  on(eventType, handler) {
+    this._handlers.set(eventType, handler);
+  }
+  registerHandlers(handlers) {
+    for (const [type, handler] of Object.entries(handlers)) {
+      this._handlers.set(type, handler);
+    }
+  }
+  // ── Event processing ──────────────────────────────────────────
+  processEvent(event) {
+    const handler = this._handlers.get(event.type);
+    if (handler === null) return;
+    if (!handler) return;
+    handler(event, this);
+  }
+  // ── State ─────────────────────────────────────────────────────
+  getBlocks() {
+    return [...this._blocks];
+  }
+  reset() {
+    this._blocks = [];
+    this.activeTextId = null;
+    this.activeThinkingId = null;
+    this.thinkingStartMs = null;
+  }
+  setOnChange(fn) {
+    this._onChange = fn;
+  }
+  // ── Block manipulation (used by handlers) ─────────────────────
+  addBlock(block) {
+    this._blocks = [...this._blocks, block];
+    this._notify();
+  }
+  updateBlock(id, updater) {
+    let changed = false;
+    this._blocks = this._blocks.map((b) => {
+      if (b.id !== id) return b;
+      changed = true;
+      return updater(b);
+    });
+    if (changed) this._notify();
+  }
+  /** Update any block by id with a partial update (type-loose for handlers). */
+  patchBlock(id, patch) {
+    let changed = false;
+    this._blocks = this._blocks.map((b) => {
+      if (b.id !== id) return b;
+      changed = true;
+      return { ...b, ...patch };
+    });
+    if (changed) this._notify();
+  }
+  findBlock(predicate) {
+    for (let i = this._blocks.length - 1; i >= 0; i--) {
+      const block = this._blocks[i];
+      if (block && predicate(block)) return block;
+    }
+    return void 0;
+  }
+  nextId() {
+    return `blk_${++_idCounter}`;
+  }
+  // ── Internal ──────────────────────────────────────────────────
+  _notify() {
+    this._onChange?.();
+  }
+};
+
 // src/storage.ts
 var InMemoryStorage = class {
   constructor() {
@@ -485,7 +566,7 @@ function generateId() {
 
 // src/session.ts
 var ChatSession = class {
-  constructor(config, storage) {
+  constructor(config, storage, blockBuilder) {
     // State
     this.conversationId = null;
     this.conversations = [];
@@ -515,6 +596,13 @@ var ChatSession = class {
     this.client = new AstralformClient(config);
     this.toolRegistry = new ToolRegistry();
     this.storage = storage ?? new InMemoryStorage();
+    this.blockBuilder = blockBuilder ?? new BlockBuilder();
+    this.blockBuilder.setOnChange(() => {
+      this.emit({
+        type: "blocks_changed",
+        blocks: this.blockBuilder.getBlocks()
+      });
+    });
   }
   on(handler) {
     this.handlers.add(handler);
@@ -523,6 +611,9 @@ var ChatSession = class {
     };
   }
   emit(event) {
+    if (event.type !== "blocks_changed" && event.type !== "connected") {
+      this.blockBuilder.processEvent(event);
+    }
     for (const handler of this.handlers) {
       try {
         handler(event);
@@ -579,14 +670,15 @@ var ChatSession = class {
     };
     await this.processStream(request);
   }
-  async resendFromCheckpoint(messageId, newContent) {
+  async resendFromCheckpoint(messageId, newContent, options) {
     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)
+      enabled_mcp: Array.from(this.enabledClientTools),
+      enable_search: options?.enableSearch
     };
     await this.processStream(request);
   }
@@ -626,12 +718,23 @@ var ChatSession = class {
     }
     const messageId = job.message_id;
     this.lastSeq = -1;
-    let stopTitle;
     const stream = this.client.streamJobEvents(
       job.job_id,
       this.lastSeq,
       this.abortController?.signal
     );
+    await this.consumeEventStream(
+      stream,
+      conversationId,
+      messageId,
+      true
+      // executeClientTools
+    );
+  }
+  /**
+   * Shared event consumption loop used by both consumeJobStream and reconnectToJob.
+   */
+  async consumeEventStream(stream, conversationId, messageId, executeClientTools) {
     for await (const raw of stream) {
       let parsed;
       try {
@@ -655,6 +758,9 @@ var ChatSession = class {
           if (!this.conversationId) {
             this.conversationId = conversationId;
           }
+          if (parsed.message_id) {
+            messageId = parsed.message_id;
+          }
           if (parsed.model_display_name) {
             this.modelDisplayName = parsed.model_display_name;
             this.emit({
@@ -669,7 +775,7 @@ var ChatSession = class {
           break;
         case "tool_use_start": {
           this.applyEvent(parsed);
-          if (parsed.is_client_tool) {
+          if (executeClientTools && parsed.is_client_tool) {
             const results = await this.executeClientTools([
               {
                 callId: parsed.call_id,
@@ -721,7 +827,15 @@ var ChatSession = class {
           });
           break;
         case "message_stop":
-          stopTitle = parsed.title;
+          await this.completeStream(
+            conversationId,
+            messageId,
+            parsed.title,
+            parsed.metrics,
+            parsed.job_id
+          );
+          this.isStreaming = false;
+          this.currentJobId = null;
           break;
         case "error":
           this.emit({
@@ -733,8 +847,6 @@ var ChatSession = class {
           this.applyEvent(parsed);
       }
     }
-    this.currentJobId = null;
-    await this.completeStream(conversationId, messageId, stopTitle);
   }
   /**
    * Apply a single SSE event to session state and notify consumers.
@@ -742,6 +854,45 @@ var ChatSession = class {
    */
   applyEvent(event) {
     switch (event.type) {
+      case "user_message":
+        this.emit({ type: "user_message", content: event.content });
+        break;
+      case "title_generated":
+        this.emit({ type: "title_generated", title: event.title });
+        break;
+      case "message_start":
+        if (event.conversation_id && !this.conversationId) {
+          this.conversationId = event.conversation_id;
+        }
+        if (event.model_display_name) {
+          this.modelDisplayName = event.model_display_name;
+          this.emit({ type: "model_info", name: event.model_display_name });
+        }
+        break;
+      case "content_block_delta":
+        this.streamingContent += event.delta.text;
+        this.emit({ type: "chunk", text: event.delta.text });
+        break;
+      case "thinking_delta":
+        this.thinkingContent += event.delta.text;
+        this.isThinking = true;
+        this.emit({ type: "thinking_delta", text: event.delta.text });
+        break;
+      case "thinking_complete":
+        this.isThinking = false;
+        this.emit({ type: "thinking_complete" });
+        break;
+      case "message_stop":
+        this.emit({
+          type: "complete",
+          content: this.streamingContent,
+          conversationId: this.conversationId ?? "",
+          messageId: event.job_id ?? "",
+          title: event.title,
+          metrics: event.metrics,
+          job_id: event.job_id
+        });
+        break;
       case "tool_use_start": {
         const request = {
           callId: event.call_id,
@@ -769,7 +920,9 @@ var ChatSession = class {
           type: "tool_end",
           callId: event.call_id,
           toolName: event.tool,
-          result: event.result
+          result: event.result,
+          sources: event.sources,
+          durationMs: event.duration_ms
         });
         break;
       }
@@ -877,18 +1030,47 @@ var ChatSession = class {
           sizeBytes: event.size_bytes
         });
         break;
-      case "activity":
+      case "timeline_entry":
         this.emit({
-          type: "activity",
-          activityId: event.activity_id,
+          type: "timeline_entry",
+          id: event.id,
           status: event.status,
-          category: event.category,
-          title: event.title,
+          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,
-          toolName: event.tool_name,
-          agentName: event.agent_name,
-          durationMs: event.duration_ms
+          parent_id: event.parent_id,
+          structured_output: event.structured_output
+        });
+        break;
+      case "editor_content_start":
+        this.emit({
+          type: "editor_content_start",
+          callId: event.call_id,
+          path: event.path,
+          language: event.language
+        });
+        break;
+      case "editor_content_delta":
+        this.emit({
+          type: "editor_content_delta",
+          callId: event.call_id,
+          path: event.path,
+          delta: event.delta
+        });
+        break;
+      case "editor_content_end":
+        this.emit({
+          type: "editor_content_end",
+          callId: event.call_id
         });
         break;
     }
@@ -916,7 +1098,7 @@ var ChatSession = class {
     this.executingTool = null;
     return results;
   }
-  async completeStream(conversationId, messageId, title) {
+  async completeStream(conversationId, messageId, title, metrics, jobId) {
     const assistantMessage = {
       id: messageId || generateId(),
       conversationId,
@@ -939,9 +1121,57 @@ var ChatSession = class {
       content: this.streamingContent,
       conversationId,
       messageId: assistantMessage.id,
-      title
+      title,
+      metrics,
+      job_id: jobId
     });
   }
+  /**
+   * Load conversation context (messages) without replaying events.
+   * Used before reconnectToJob — SSE replay handles event replay.
+   */
+  async loadConversation(id) {
+    this.conversationId = id;
+    this.resetStreamingState();
+    this.blockBuilder.reset();
+    this.messages = await this.client.getMessages(id).catch(() => this.storage.fetchMessages(id));
+  }
+  /**
+   * Reconnect to a running job's SSE stream (e.g. after page reload).
+   * Replays all events from the beginning and continues live.
+   * Does NOT reset BlockBuilder — caller controls reset.
+   */
+  async reconnectToJob(jobId) {
+    if (this.isStreaming) return;
+    this.isStreaming = true;
+    this.currentJobId = jobId;
+    this.lastSeq = -1;
+    this.resetStreamingState();
+    this.abortController = new AbortController();
+    try {
+      const stream = this.client.streamJobEvents(
+        jobId,
+        this.lastSeq,
+        this.abortController?.signal
+      );
+      await this.consumeEventStream(
+        stream,
+        this.conversationId ?? "",
+        "",
+        false
+        // don't execute client tools on reconnect
+      );
+    } 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;
+    }
+  }
   disconnect() {
     if (this.currentJobId) {
       this.client.cancelJob(this.currentJobId).catch(() => {
@@ -970,6 +1200,7 @@ var ChatSession = class {
   async switchConversation(id) {
     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)
@@ -977,20 +1208,10 @@ var ChatSession = class {
     this.messages = messagesResult.status === "fulfilled" ? messagesResult.value : [];
     if (eventsResult.status === "fulfilled") {
       for (const ev of eventsResult.value) {
-        this.replayEvent(ev.event, ev.data);
+        this.applyEvent({ type: ev.event, ...ev.data });
       }
     }
   }
-  /**
-   * Replay a single persisted event to reconstruct session state.
-   * Skips text deltas (final content is already in messages[]).
-   */
-  replayEvent(eventType, data) {
-    if (eventType === "content_block_delta" || eventType === "thinking_delta" || eventType === "subagent_content_delta" || eventType === "thinking_complete") {
-      return;
-    }
-    this.applyEvent({ type: eventType, ...data });
-  }
   async deleteConversation(id) {
     try {
       await this.client.deleteConversation(id);
@@ -1012,10 +1233,231 @@ var ChatSession = class {
     return true;
   }
 };
+
+// src/standard-handlers.ts
+function finalizeText(builder) {
+  if (builder.activeTextId) {
+    builder.patchBlock(builder.activeTextId, {
+      isStreaming: false
+    });
+    builder.activeTextId = null;
+  }
+}
+function finalizeThinking(builder) {
+  if (builder.activeThinkingId) {
+    builder.patchBlock(builder.activeThinkingId, {
+      isActive: false
+    });
+    builder.activeThinkingId = null;
+    builder.thinkingStartMs = 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 });
+};
+var handleChunk = (event, builder) => {
+  const e = event;
+  if (!builder.activeTextId) {
+    const id = builder.nextId();
+    builder.activeTextId = id;
+    builder.addBlock({
+      type: "text",
+      id,
+      content: e.text,
+      isStreaming: true
+    });
+  } else {
+    const id = builder.activeTextId;
+    const existing = builder.findBlock((b) => b.id === id);
+    if (existing && existing.type === "text") {
+      builder.patchBlock(id, {
+        content: existing.content + e.text
+      });
+    }
+  }
+};
+var handleToolCall = (event, builder) => {
+  const e = event;
+  finalizeText(builder);
+  builder.addBlock({
+    type: "tool",
+    id: builder.nextId(),
+    callId: e.request.callId,
+    toolName: e.request.toolName,
+    displayName: e.request.displayName,
+    description: e.request.description,
+    arguments: e.request.arguments,
+    toolCategory: e.request.toolCategory,
+    iconUrl: e.request.iconUrl,
+    status: "calling"
+  });
+};
+var handleToolExecuting = (event, builder) => {
+  const e = event;
+  const block = builder.findBlock(
+    (b) => b.type === "tool" && b.toolName === e.name && b.status === "calling"
+  );
+  if (block) {
+    builder.patchBlock(block.id, { status: "executing" });
+  }
+};
+var handleToolEnd = (event, builder) => {
+  const e = event;
+  const callId = e.type === "tool_end" ? e.callId : void 0;
+  const name = e.type === "tool_end" ? e.toolName : e.name;
+  const block = builder.findBlock(
+    (b) => b.type === "tool" && (callId ? b.callId === callId : b.toolName === name) && b.status !== "completed"
+  );
+  if (block) {
+    const toolEnd = e.type === "tool_end" ? e : null;
+    builder.patchBlock(block.id, {
+      status: "completed",
+      ...toolEnd?.sources ? { sources: toolEnd.sources } : {},
+      ...toolEnd?.durationMs != null ? { durationMs: toolEnd.durationMs } : {},
+      ...toolEnd?.result ? { result: toolEnd.result } : {}
+    });
+  }
+};
+var handleAgentStart = (event, builder) => {
+  const e = event;
+  finalizeText(builder);
+  builder.addBlock({
+    type: "agent",
+    id: builder.nextId(),
+    agentName: e.agentName,
+    displayName: e.agentDisplayName,
+    avatarUrl: e.avatarUrl
+  });
+};
+var handleThinkingDelta = (event, builder) => {
+  const e = event;
+  if (!builder.activeThinkingId) {
+    const id = builder.nextId();
+    builder.activeThinkingId = id;
+    builder.thinkingStartMs = Date.now();
+    builder.addBlock({
+      type: "thinking",
+      id,
+      content: e.text,
+      isActive: true
+    });
+  } else {
+    const id = builder.activeThinkingId;
+    const existing = builder.findBlock((b) => b.id === id);
+    if (existing && existing.type === "thinking") {
+      builder.patchBlock(id, {
+        content: existing.content + e.text
+      });
+    }
+  }
+};
+var handleThinkingComplete = (_event, builder) => {
+  if (builder.activeThinkingId) {
+    const durationMs = builder.thinkingStartMs ? Math.max(0, Date.now() - builder.thinkingStartMs) : void 0;
+    builder.patchBlock(builder.activeThinkingId, {
+      isActive: false,
+      durationMs
+    });
+    builder.activeThinkingId = null;
+    builder.thinkingStartMs = null;
+  }
+};
+var handleSubagentStart = (event, builder) => {
+  const e = event;
+  finalizeText(builder);
+  builder.addBlock({
+    type: "subagent",
+    id: builder.nextId(),
+    agentName: e.agentName,
+    displayName: e.displayName,
+    toolCallId: e.toolCallId,
+    avatarUrl: e.avatarUrl,
+    description: e.description,
+    content: "",
+    isActive: true
+  });
+};
+var handleSubagentChunk = (event, builder) => {
+  const e = event;
+  const block = builder.findBlock(
+    (b) => b.type === "subagent" && b.toolCallId === e.toolCallId
+  );
+  if (block && block.type === "subagent") {
+    builder.patchBlock(block.id, {
+      content: block.content + e.text
+    });
+  }
+};
+var handleSubagentUpdate = (event, builder) => {
+  const e = event;
+  const block = builder.findBlock(
+    (b) => b.type === "subagent" && b.toolCallId === e.toolCallId
+  );
+  if (block) {
+    builder.patchBlock(block.id, {
+      displayName: e.displayName
+    });
+  }
+};
+var handleSubagentEnd = (event, builder) => {
+  const e = event;
+  const block = builder.findBlock(
+    (b) => b.type === "subagent" && b.toolCallId === e.toolCallId
+  );
+  if (block) {
+    builder.patchBlock(block.id, {
+      isActive: false
+    });
+  }
+};
+var handleComplete = (_event, builder) => {
+  finalizeText(builder);
+  finalizeThinking(builder);
+  for (const b of builder.getBlocks()) {
+    if (b.type === "tool" && b.status !== "completed") {
+      builder.patchBlock(b.id, { status: "completed" });
+    }
+  }
+};
+var handleError = (event, builder) => {
+  const e = event;
+  finalizeText(builder);
+  finalizeThinking(builder);
+  builder.addBlock({
+    type: "error",
+    id: builder.nextId(),
+    message: e.error.message
+  });
+};
+var handleDisconnected = (_event, builder) => {
+  finalizeText(builder);
+  finalizeThinking(builder);
+};
+var standardHandlers = {
+  user_message: handleUserMessage,
+  chunk: handleChunk,
+  tool_call: handleToolCall,
+  tool_executing: handleToolExecuting,
+  tool_completed: handleToolEnd,
+  tool_end: handleToolEnd,
+  agent_start: handleAgentStart,
+  thinking_delta: handleThinkingDelta,
+  thinking_complete: handleThinkingComplete,
+  subagent_start: handleSubagentStart,
+  subagent_chunk: handleSubagentChunk,
+  subagent_update: handleSubagentUpdate,
+  subagent_end: handleSubagentEnd,
+  complete: handleComplete,
+  error: handleError,
+  disconnected: handleDisconnected
+};
 export {
   AstralformClient,
   AstralformError,
   AuthenticationError,
+  BlockBuilder,
   ChatSession,
   ConnectionError,
   InMemoryStorage,
@@ -1025,6 +1467,7 @@ export {
   StreamAbortedError,
   ToolRegistry,
   generateId,
+  standardHandlers,
   streamJobSSE
 };
 //# sourceMappingURL=index.js.map