@anhlp/alp-runtime 0.0.0-beta.2 → 0.0.1-beta.3

package/dist/claude-transport.d.ts

@@ -114,6 +114,7 @@ export declare class ClaudeTransport {
     private activeTurn?;
     private closed;
     private assistantText;
+    private streamingMessage?;
     private toolCalls;
     /** The last rate limit Claude reported, and whether the running turn hit one. */
     private rateLimit?;
@@ -165,6 +166,8 @@ export declare class ClaudeTransport {
     private consume;
     private handle;
     private emit;
+    private assistantState;
+    private clearAssistantText;
     private fail;
     close(): Promise<void>;
 }

package/dist/claude-transport.js

@@ -51,12 +51,14 @@ var toolShapes = {
     body: z.string().min(1).max(2e4),
     roles: z.array(z.string().min(1)).min(1).max(10),
     lessons: z.array(z.string().min(1).max(600)).max(50).optional(),
-    replace: z.boolean().optional()
+    replace: z.boolean().optional(),
+    requestId: z.string().min(1).max(100).optional()
   },
   alp_issue: {
     action: z.enum(["search", "create", "comment"]),
     target: z.enum(["project", "alp"]),
     query: z.string().min(1).max(200).optional(),
+    requestId: z.string().min(1).max(100).optional(),
     title: z.string().min(1).max(200).optional(),
     body: z.string().min(1).max(2e4).optional(),
     issue: z.number().int().positive().optional(),
@@ -285,6 +287,7 @@ var ClaudeTransport = class {
   activeTurn;
   closed = false;
   assistantText = /* @__PURE__ */ new Map();
+  streamingMessage;
   toolCalls = /* @__PURE__ */ new Map();
   /** The last rate limit Claude reported, and whether the running turn hit one. */
   rateLimit;
@@ -353,6 +356,7 @@ var ClaudeTransport = class {
       return {};
     }
     if (method === "thread/start" || method === "thread/resume" || method === "thread/fork") {
+      this.clearAssistantText();
       this.config = params;
       this.threadId = method === "thread/resume" ? params.threadId : randomUUID();
       await this.start(method === "thread/start" ? void 0 : { resume: params.threadId, fork: method === "thread/fork" });
@@ -366,7 +370,10 @@ var ClaudeTransport = class {
     if (method === "turn/start" || method === "turn/steer") {
       if (!this.query) throw new Error("Claude thread is not initialized");
       const turnId = method === "turn/steer" ? params.expectedTurnId : randomUUID();
-      if (method === "turn/start") this.activeTurn = turnId;
+      if (method === "turn/start") {
+        this.clearAssistantText();
+        this.activeTurn = turnId;
+      }
       this.input.push({
         type: "user",
         message: {
@@ -380,6 +387,7 @@ var ClaudeTransport = class {
       return method === "turn/start" ? { turn: { id: turnId } } : {};
     }
     if (method === "turn/interrupt") {
+      this.streamingMessage = void 0;
       await this.query?.interrupt();
       return {};
     }
@@ -483,7 +491,7 @@ var ClaudeTransport = class {
       ...plugins.length ? { plugins } : {},
       persistSession: !config.ephemeral,
       promptSuggestions: false,
-      includePartialMessages: false,
+      includePartialMessages: true,
       ...from ? { resume: from.resume, ...from.fork ? { forkSession: true, sessionId: this.threadId } : {} } : { sessionId: this.threadId },
       // Explicit native path avoids SDK optional binaries inside Electron app.asar.
       pathToClaudeCodeExecutable: this.command
@@ -521,15 +529,42 @@ var ClaudeTransport = class {
     if (!this.closed) this.fail(new Error("Claude session exited"));
   }
   handle(message) {
+    if (this.closed) return;
     if (message.type === "rate_limit_event") {
       this.rateLimit = message.rate_limit_info;
       this.emit("account/rateLimits/updated", { claude: message.rate_limit_info });
       return;
     }
-    if (message.type === "assistant" && !message.parent_tool_use_id && !this.activeTurn && !this.closed) {
+    const streamStart = message.type === "stream_event" && message.event?.type === "message_start";
+    if ((message.type === "assistant" || streamStart) && !message.parent_tool_use_id && !this.activeTurn) {
       this.activeTurn = randomUUID();
       this.emit("turn/started", { threadId: this.threadId, turn: { id: this.activeTurn } });
     }
+    if (message.type === "stream_event") {
+      if (message.parent_tool_use_id) return;
+      const event = message.event;
+      if (event.type === "message_start") {
+        this.streamingMessage = event.message.id;
+      } else if (event.type === "message_stop") {
+        this.streamingMessage = void 0;
+      } else if (this.streamingMessage) {
+        const id = this.streamingMessage;
+        const state = this.assistantState(id);
+        let delta;
+        if (event.type === "content_block_start" && event.content_block.type === "text") {
+          state.blocks.set(event.index, { text: event.content_block.text, final: false });
+          delta = event.content_block.text;
+        } else if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+          const block = state.blocks.get(event.index);
+          if (block && !block.final) {
+            block.text += event.delta.text;
+            delta = event.delta.text;
+          }
+        }
+        if (delta) this.emit("item/agentMessage/delta", { threadId: this.threadId, turnId: this.activeTurn, itemId: id, delta });
+      }
+      return;
+    }
     if (message.type === "assistant" && message.error === "rate_limit") this.limitedTurn = true;
     if (message.type === "system" && (message.subtype === "status" || message.subtype === "compact_boundary")) {
       const system = message;
@@ -567,14 +602,18 @@ var ClaudeTransport = class {
       if (windows.length && !this.compactAt) this.contextWindow = Math.max(...windows);
     }
     if (message.type === "assistant" && !message.parent_tool_use_id) {
+      const id = message.message.id;
+      const state = this.assistantState(id);
+      if (message.uuid && state.seen.has(message.uuid)) return;
+      if (message.uuid) state.seen.add(message.uuid);
       for (const block of message.message.content) {
         if (block.type === "text") {
-          const id = message.message.id;
-          const text = (this.assistantText.get(id) ?? "") + block.text;
-          this.assistantText.set(id, text);
+          const pending = [...state.blocks.entries()].sort(([a], [b]) => a - b).find(([, value]) => !value.final);
+          const index = pending?.[0] ?? Math.max(-1, ...state.blocks.keys()) + 1;
+          state.blocks.set(index, { text: block.text, final: true });
           this.emit("item/completed", {
             threadId: this.threadId,
-            item: { type: "agentMessage", id, text }
+            item: { type: "agentMessage", id, text: [...state.blocks.entries()].sort(([a], [b]) => a - b).map(([, block2]) => block2.text).join("") }
           });
         } else if (block.type === "tool_use") {
           const command = block.name === "Bash" ? String(block.input?.command ?? "") : `${block.name} ${JSON.stringify(block.input ?? {})}`;
@@ -623,6 +662,7 @@ var ClaudeTransport = class {
       }
       return;
     }
+    if (message.type === "result") this.clearAssistantText();
     if (message.type === "result" && this.activeTurn) {
       const turnId = this.activeTurn;
       this.activeTurn = void 0;
@@ -645,14 +685,25 @@ var ClaudeTransport = class {
   emit(method, params) {
     for (const listener of this.listeners) listener(method, params);
   }
+  assistantState(id) {
+    let state = this.assistantText.get(id);
+    if (!state) this.assistantText.set(id, state = { blocks: /* @__PURE__ */ new Map(), seen: /* @__PURE__ */ new Set() });
+    return state;
+  }
+  clearAssistantText() {
+    this.streamingMessage = void 0;
+    this.assistantText.clear();
+  }
   fail(value) {
     if (this.closed) return;
+    this.clearAssistantText();
     const error = value instanceof Error ? value : new Error(String(value));
     for (const listener of this.failures) listener(error);
   }
   async close() {
     if (this.closed) return;
     this.closed = true;
+    this.clearAssistantText();
     this.input.close();
     this.query?.close();
     await this.pump?.catch(() => {

package/dist/contracts.d.ts

@@ -146,9 +146,10 @@ export type AlpRuntime = {
     }, question: string): Promise<RecallAnswer>;
     /** Assignments an earlier alpd left running, which recover() can continue once their root is open again. */
     recoverable(): LiveEntry[];
-    /** Continues the assignments an earlier alpd left running in an open root's tree; with continueRoot, the root's own turn too. */
+    /** Continues work in a reopened tree. continueRoot resumes its running turn; parkedRoot restores its held continuation intent. */
     recover(rootId: string, options?: {
         continueRoot?: boolean;
+        parkedRoot?: string;
     }): Promise<RecoveryOutcome[]>;
     /** Gives up the assignments of a tree whose root cannot be opened again: their tasks go back to open. */
     abandon(rootId: string, reason: string): Promise<RecoveryOutcome[]>;

package/dist/runtime-context.d.ts

@@ -37,7 +37,7 @@ export declare function claudeUsage(result: any): {
 };
 /**
  * Whether a runtime's usage report (codexUsage or claudeUsage) lets it work again (ALPD §58):
- * true when every window has room, false when one is used up or spending is capped, and
+ * true when every window has room, false on explicit provider denial, a used-up window or spending cap, and
  * undefined when the report says nothing either way.
  */
 export declare function usageAllows(usage: any): boolean | undefined;

package/dist/runtime-context.js

@@ -46,7 +46,7 @@ function claudeUsage(result) {
 function usageAllows(usage) {
   if (!usage?.available) return void 0;
   const limits = Array.isArray(usage.limits) ? usage.limits : [];
-  if (limits.some((limit) => limit?.spendControlReached === true)) return false;
+  if (usage.ordinaryUsageAllowed === false || limits.some((limit) => limit?.spendControlReached === true)) return false;
   const windows = limits.length ? limits.flatMap((limit) => limit?.windows ?? []) : usage.windows ?? [];
   const known = windows.filter((window) => typeof window?.usedPercent === "number");
   if (!known.length) return void 0;