@rowan-agent/agent 0.7.5 → 0.8.0

package/README.md

@@ -1,8 +1,8 @@
 # @rowan-agent/agent
 
-Durable Agent Runtime. The public API consists of `AgentRuntime`, Durable
-Stores, Config Providers, Run handles, and Durable Run Events. An Agent is a
-persistent identity, not a process-local Session object.
+Durable Agent Runtime. The public interface consists of `AgentRuntime`, Durable
+Stores, Config Providers, Run handles, and Run Events. An Agent is a persistent
+identity, not a process-local Session object.
 
 ## Quick start
 
@@ -31,7 +31,13 @@ const agentId = await runtime.createAgent({
 const run = await runtime.start(agentId, "Summarize the workspace.", {
   idempotencyKey: "run-example", // One Agent can have multiple independent Runs
 });
+const observing = (async () => {
+  for await (const event of run.observe()) {
+    if (event.kind === "message_delta") process.stdout.write(event.text);
+  }
+})();
 const boundary = await run.wait();
+await observing;
 await runtime.close();
 ```
 
@@ -40,7 +46,7 @@ await runtime.close();
 1. `AgentRuntime.init({ store })` opens a Runtime Owner with an in-memory Config Provider by default. Pass `configs` when configuration must survive process boundaries.
 2. `createAgent()` creates a persistent Agent identity and binds a configuration snapshot.
 3. `start()` creates a queued Run; `run(runId)` returns a stateless Run handle.
-4. `observe()` reads replayable `DurableRunEvent` values; `wait()` waits for a boundary.
+4. `observe()` follows display-oriented `RunEvent` values; `wait()` waits for an authoritative boundary.
 5. `respond()` continues an `input_required` Run; `cancel()` terminates an unfinished Run.
 6. `close()` seals the Owner and releases the Store.
 
@@ -69,16 +75,29 @@ Tools are supplied through `AgentConfig.context.tools` and persist through:
 When an external side effect cannot be confirmed, the Tool must become
 `indeterminate`; the Run then fails and is never automatically retried.
 
+While running, a Tool may call `context.reportProgress(progress)` with a
+JSON-safe value. Progress is live-only and may be dropped.
+
 ## Events
 
-`run.observe()` and `runtime.consume()` deliver only Durable Run Events:
+`run.observe()` delivers `RunEvent` values for live presentation:
+
+- transient `message_delta` and `tool_progress` events are live-only and
+  best-effort;
+- durable `message_committed`, `run_transitioned`, and `tool_state_changed`
+  events are replayable;
+- a durable `message_committed` event is the authoritative full content if a
+  transient delta was coalesced or dropped.
+
+`runtime.consume()` delivers only `DurableRunEvent` values:
 
 - `message_committed`
 - `run_transitioned`
 - `tool_state_changed`
 
-Events and their corresponding Run aggregate changes commit in one Store
-transaction. Consumers persist their progress through cursors and checkpoints.
+Durable events and their corresponding Run aggregate changes commit in one
+Store transaction. Reliable consumers persist progress through cursors and
+checkpoints; transient events never enter the Durable Store.
 
 ## Resources
 

package/dist/index.d.ts

@@ -71,6 +71,7 @@ type PhaseExecution = {
     restore(snapshot: PhaseContextSnapshot): void;
     invokeModel(context: PhaseContext): Promise<ModelInvokeOutput>;
     executeTool(context: AgentContext, toolCall: ToolCall): Promise<ToolResult>;
+    executeTools(context: AgentContext, toolCalls: readonly ToolCall[]): Promise<readonly ToolResult[]>;
 };
 
 /**
@@ -461,6 +462,12 @@ type PhaseInvocation = {
     count: number;
     sourcePhaseId: string;
 };
+/** Durable identity of the Run execution currently invoking a Phase. */
+type PhaseExecutionIdentity = Readonly<{
+    agentId: string;
+    runId: string;
+    executionId: string;
+}>;
 /** Everything a phase needs to execute */
 interface PhaseContext {
     systemPrompt: string;
@@ -473,6 +480,8 @@ interface PhaseContext {
     state: PhaseState;
     /** Identity and dispatch metadata for this phase execution */
     readonly invocation: PhaseInvocation;
+    /** Durable Run identity for cross-store integrations and idempotent commands. */
+    readonly execution: PhaseExecutionIdentity;
     /** Additional guideline bullets appended to the system prompt */
     promptGuidelines?: string[];
     /** Text to append after the system prompt */
@@ -597,6 +606,8 @@ type ThinkingContent = Readonly<{
 type ToolUseContent = Readonly<{
     type: "tool_use";
     toolCallId: ToolCallId;
+    /** Provider/model correlation, retained only to reconstruct the next request. */
+    providerToolCallId?: string;
     name: string;
     input: JsonValue;
 }>;
@@ -615,6 +626,8 @@ type DurableToolResult = Readonly<{
 type ToolResultContent = Readonly<{
     type: "tool_result";
     toolCallId: ToolCallId;
+    /** Provider/model correlation, retained only to reconstruct the next request. */
+    providerToolCallId?: string;
     result: ToolExecutionResult;
 }>;
 type UserContent = string | readonly (TextContent | ImageContent)[];
@@ -685,6 +698,7 @@ type RunningRunFailure = Extract<RunFailure, {
 type ToolCallState = "pending" | "running" | "completed" | "failed" | "indeterminate";
 type ToolCallSnapshotBase = Readonly<{
     id: ToolCallId;
+    providerToolCallId: string;
     agentId: AgentId;
     runId: RunId;
     executionId: ExecutionId;
@@ -831,6 +845,24 @@ type ToolStateChanged = DurableEventBase & (Readonly<{
     }>;
 }>);
 type DurableRunEvent = MessageCommitted | RunTransitioned | ToolStateChanged;
+type MessageDelta = Readonly<{
+    kind: "message_delta";
+    durability: "transient";
+    runId: RunId;
+    executionId: ExecutionId;
+    messageId: MessageId;
+    offset: number;
+    text: string;
+}>;
+type ToolProgress = Readonly<{
+    kind: "tool_progress";
+    durability: "transient";
+    runId: RunId;
+    executionId: ExecutionId;
+    toolCallId: ToolCallId;
+    progress: JsonValue;
+}>;
+type RunEvent = DurableRunEvent | MessageDelta | ToolProgress;
 
 type UserInput = string | Readonly<{
     content: UserContent;
@@ -840,6 +872,7 @@ type ToolInvocationContext = Readonly<{
     agentId: AgentId;
     runId: RunId;
     toolCallId: ToolCallId;
+    reportProgress(progress: JsonValue): void;
 }>;
 type Tool = Readonly<{
     name: string;
@@ -930,10 +963,20 @@ type InputRequiredCommit = Readonly<{
     prompt: AssistantMessage;
     request: InputRequest;
 }>;
+type ToolCallReservation = Readonly<{
+    providerToolCallId: string;
+    name: string;
+    args: JsonValue;
+    toolCallId?: ToolCallId;
+}>;
 type ToolCommit = Readonly<{
     run: RunRecord;
     toolCall: ToolCallSnapshot;
 }>;
+type ToolBatchCommit = Readonly<{
+    run: RunRecord;
+    toolCalls: readonly ToolCallSnapshot[];
+}>;
 type RunRecord = Readonly<{
     id: RunId;
     agentId: AgentId;
@@ -1115,7 +1158,15 @@ interface OwnedStore {
         name: string;
         args: JsonValue;
         toolCallId?: ToolCallId;
+        providerToolCallId?: string;
     }): Promise<ToolCommit>;
+    reserveToolCalls(input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        calls: readonly ToolCallReservation[];
+    }): Promise<ToolBatchCommit>;
     startToolCall(input: {
         runId: RunId;
         execution: ExecutionToken;
@@ -1175,7 +1226,7 @@ interface AgentRun {
     observe(options?: {
         after?: EventCursor;
         signal?: AbortSignal;
-    }): AsyncIterable<DurableRunEvent>;
+    }): AsyncIterable<RunEvent>;
     wait(options?: {
         signal?: AbortSignal;
     }): Promise<RunBoundary>;
@@ -1230,6 +1281,7 @@ declare class AgentRuntime implements AgentRuntime$1 {
     private readonly activeAgents;
     private readonly executions;
     private readonly consumers;
+    private readonly transientEvents;
     private heartbeat?;
     private pumping;
     private closed;
@@ -1275,12 +1327,14 @@ declare class AgentRuntime implements AgentRuntime$1 {
     private execute;
     private failQueued;
     private executeTool;
+    private executeToolBatch;
+    private executeReservedTool;
     private requireAgent;
     private runConsumer;
     observe(runId: RunId, options?: {
         after?: EventCursor;
         signal?: AbortSignal;
-    }): AsyncIterable<DurableRunEvent>;
+    }): AsyncIterable<RunEvent>;
     wait(runId: RunId, options?: {
         signal?: AbortSignal;
     }): Promise<RunBoundary>;
@@ -1390,7 +1444,20 @@ declare class InMemoryStore implements DurableStore {
         name: string;
         args: JsonValue;
         toolCallId?: ToolCallId;
+        providerToolCallId?: string;
     }): ToolCommit;
+    reserveToolCalls(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        calls: readonly Readonly<{
+            providerToolCallId: string;
+            name: string;
+            args: JsonValue;
+            toolCallId?: ToolCallId;
+        }>[];
+    }): ToolBatchCommit;
     startToolCall(lease: OwnerLease, input: {
         runId: RunId;
         execution: ExecutionToken;
@@ -1531,7 +1598,20 @@ declare class SqliteStore implements DurableStore {
         name: string;
         args: JsonValue;
         toolCallId?: ToolCallId;
+        providerToolCallId?: string;
     }): Promise<ToolCommit>;
+    reserveToolCalls(lease: OwnerLease, input: {
+        runId: RunId;
+        execution: ExecutionToken;
+        expectedRevision: number;
+        requestMessageId: MessageId;
+        calls: readonly Readonly<{
+            providerToolCallId: string;
+            name: string;
+            args: JsonValue;
+            toolCallId?: ToolCallId;
+        }>[];
+    }): Promise<ToolBatchCommit>;
     startToolCall(lease: OwnerLease, input: {
         runId: RunId;
         execution: ExecutionToken;
@@ -1720,4 +1800,4 @@ declare function loadExtensionsFromPath(path: string): Promise<{
 
 declare function createCoreTools(input?: CoreToolContext): Tool[];
 
-export { type AfterToolCall, type AgentConfig, type AgentDefinitionContext, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type CoreToolContext, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionFactory, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageId, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseInvocation, type PhaseOutput, type PhaseRegistry, type PhaseState, type RunBoundary, type RunClaim, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunSummary, type RunTransitioned, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, type Skill, SqliteStore, type TextContent, type ThinkingContent, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolDefinition, type ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCoreTools, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhases, loadSkills };
+export { type AfterToolCall, type AgentConfig, type AgentDefinitionContext, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type CoreToolContext, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionFactory, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseExecutionIdentity, type PhaseInvocation, type PhaseOutput, type PhaseRegistry, type PhaseState, type RunBoundary, type RunClaim, type RunEvent, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunSummary, type RunTransitioned, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, type Skill, SqliteStore, type TextContent, type ThinkingContent, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolDefinition, type ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCoreTools, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhases, loadSkills };

package/dist/index.js

@@ -832,12 +832,11 @@ async function collectStreamResult(input) {
     if (event.type === "text_delta") {
       lastPartial = event.partial;
       if (!activeMessageId) {
-        activeMessageId = input.message.start("assistant", event.text, {
+        activeMessageId = input.message.reserve("assistant", {
           phase: input.metadataPhase
         });
-      } else {
-        await input.message.update(activeMessageId, event.text);
       }
+      await input.message.update(activeMessageId, event.text);
     }
     if (event.type === "tool_call_start" || event.type === "tool_call_delta" || event.type === "tool_call_end") {
       activeMessageId ??= input.message.reserve("assistant", {
@@ -1541,7 +1540,7 @@ function createRunResult(config, state, outcome) {
 }
 async function completeRun(config, state, outcome) {
   if (outcome.display) {
-    const messages = createMessageManager(config.context, config.onMessage);
+    const messages = createMessageManager(config.context, config.onMessage, config.onMessageDelta);
     const messageId = messages.start("assistant", outcome.message, { outcomeId: outcome.id });
     await messages.end(messageId);
   }
@@ -1560,7 +1559,7 @@ function buildToolsWithRouting(config, availablePhases) {
   }
   return tools;
 }
-function createMessageManager(context, onMessage) {
+function createMessageManager(context, onMessage, onMessageDelta) {
   const activeMessages = /* @__PURE__ */ new Map();
   const emitStart = (active) => {
     if (active.emitted) return;
@@ -1584,7 +1583,12 @@ function createMessageManager(context, onMessage) {
       const active = activeMessages.get(messageId);
       if (!active) return;
       emitStart(active);
+      const offset = typeof active.message.content === "string" ? active.message.content.length : active.message.content.reduce(
+        (length, part) => length + (part.type === "text" ? part.text.length : 0),
+        0
+      );
       active.message.content = typeof active.message.content === "string" ? active.message.content + delta : [...active.message.content, { type: "text", text: delta }];
+      onMessageDelta?.({ messageId, offset, text: delta });
     },
     replaceContent(messageId, content) {
       const active = activeMessages.get(messageId);
@@ -1670,8 +1674,8 @@ async function executePhaseWithModel(ctx) {
     if (executableToolCalls.length === 0) {
       return output;
     }
-    for (const toolCall of executableToolCalls) {
-      const result = await ctx.execution.executeTool(roundContext, toolCall);
+    const results = await ctx.execution.executeTools(roundContext, executableToolCalls);
+    for (const result of results) {
       const messageId = ctx.messageManager.start("tool", createToolResultContent(result), {
         phase: ctx.phase.name
       });
@@ -1731,7 +1735,7 @@ async function runPhaseLoop(config, state, registry) {
     }
     state.currentPhase = currentPhaseId;
     const allTools = buildToolsWithRouting(config, availablePhases);
-    const messageManager = createMessageManager(config.context, config.onMessage);
+    const messageManager = createMessageManager(config.context, config.onMessage, config.onMessageDelta);
     const toolExecutionManager = createToolExecutionManager();
     const execution = createPhaseExecution(config, state, phase, messageManager, toolExecutionManager, registry);
     const phaseTools = phase.tools ? allTools.filter((t) => t.name === PhaseRouteTool || phase.tools.includes(t.name)) : allTools;
@@ -1745,6 +1749,7 @@ async function runPhaseLoop(config, state, registry) {
         mode: "serial",
         instanceId: currentPhaseId
       },
+      execution: config.execution,
       state: {
         current: currentPhaseId,
         available: Array.from(registry.phases.keys()),
@@ -2098,6 +2103,25 @@ async function executeToolCall(input) {
     toolName: input.toolCall.name
   };
 }
+async function executeToolCalls(input) {
+  if (input.config.runtime?.toolsBatch) {
+    const results2 = await input.config.runtime.toolsBatch({
+      config: input.config,
+      toolCalls: input.toolCalls
+    });
+    if (results2.length !== input.toolCalls.length) throw new Error("Runtime returned an invalid Tool batch result");
+    return results2.map((result, index) => ({
+      ...result,
+      toolCallId: input.toolCalls[index].id,
+      toolName: input.toolCalls[index].name
+    }));
+  }
+  const results = [];
+  for (const toolCall of input.toolCalls) {
+    results.push(await executeToolCall({ ...input, toolCall }));
+  }
+  return results;
+}
 function createPhaseExecution(config, state, phase, messageManager, toolExecutionManager, registry) {
   return {
     snapshot() {
@@ -2175,6 +2199,30 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
         await toolExecutionManager.end(result.toolCallId, result.toolName, result, !result.ok);
         return result;
       });
+    },
+    async executeTools(phaseContext, toolCalls) {
+      return runTurn(async () => {
+        const tools = phaseContext.tools.filter((tool) => tool.name !== PhaseRouteTool);
+        for (const toolCall of toolCalls) {
+          await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.args);
+        }
+        const results = await executeToolCalls({
+          config: {
+            ...config,
+            context: {
+              ...config.context,
+              tools,
+              skills: phaseContext.skills
+            }
+          },
+          tools,
+          toolCalls
+        });
+        for (const result of results) {
+          await toolExecutionManager.end(result.toolCallId, result.toolName, result, !result.ok);
+        }
+        return results;
+      });
     }
   };
 }
@@ -2197,6 +2245,7 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
       count,
       sourcePhaseId
     },
+    execution: config.execution,
     state: {
       current: phase.name,
       available: Array.from(registry.phases.keys()),
@@ -2204,7 +2253,7 @@ async function executeParallelPhase(config, state, registry, phase, payload, con
       payload
     }
   };
-  const messageManager = createMessageManager({ messages }, config.onMessage);
+  const messageManager = createMessageManager({ messages }, config.onMessage, config.onMessageDelta);
   const phaseMsgId = injectPhaseContent(
     phase,
     { results: payload !== void 0 ? [{ name: sourcePhaseId, output: payload }] : [] },
@@ -2395,6 +2444,7 @@ async function executeOnce(input) {
   };
   const config = {
     context,
+    execution: input.execution,
     model: input.model,
     stream: input.stream,
     maxAttempts: input.maxAttempts,
@@ -2405,6 +2455,7 @@ async function executeOnce(input) {
     afterPhase: input.afterPhase,
     beforePrompt: input.beforePrompt,
     onMessage: input.onMessage,
+    onMessageDelta: input.onMessageDelta,
     onOutcome: input.onOutcome,
     onModelTranscript: input.onModelTranscript,
     runtime: input.runtime,
@@ -2911,13 +2962,13 @@ function projectAssistantContent(content) {
   return content.map((part) => {
     if (part.type === "text") return { ...part };
     if (part.type === "thinking") return { ...part };
-    return { type: "tool_use", id: part.toolCallId, name: part.name, input: part.input };
+    return { type: "tool_use", id: part.providerToolCallId ?? part.toolCallId, name: part.name, input: part.input };
   });
 }
 function projectToolContent(content) {
   return content.map((part) => ({
     type: "tool_result",
-    toolUseId: part.toolCallId,
+    toolUseId: part.providerToolCallId ?? part.toolCallId,
     content: jsonText(part.result.content),
     ...part.result.ok ? {} : { isError: true }
   }));
@@ -2931,7 +2982,8 @@ function projectTool(tool, agentId, runId) {
       const result = await tool.execute(args, {
         agentId,
         runId,
-        toolCallId: context.toolCallId
+        toolCallId: context.toolCallId,
+        reportProgress: () => void 0
       }, signal ?? new AbortController().signal);
       return { toolCallId: context.toolCallId, toolName: tool.name, ...result };
     }
@@ -3623,6 +3675,144 @@ function fromLoopResult(result) {
   return result.ok ? { ok: true, content: result.content } : { ok: false, content: result.content, error: result.error ?? "Extension hook rejected the Tool result." };
 }
 
+// src/runtime/transient-run-events.ts
+var MAX_BUFFERED_EVENTS = 128;
+var MAX_BUFFERED_TEXT = 64 * 1024;
+function deferred() {
+  let resolve6;
+  const promise = new Promise((done) => {
+    resolve6 = done;
+  });
+  return { promise, resolve: resolve6 };
+}
+var TransientRunEventSubscription = class {
+  queue = [];
+  wake = deferred();
+  version = 0;
+  stopped = false;
+  push(event) {
+    if (this.stopped) return;
+    const previous = this.queue.at(-1);
+    if (previous?.kind === "message_delta" && event.kind === "message_delta" && previous.executionId === event.executionId && previous.messageId === event.messageId && previous.offset + previous.text.length === event.offset) {
+      this.queue[this.queue.length - 1] = {
+        ...previous,
+        text: previous.text + event.text
+      };
+    } else {
+      if (this.queue.length >= MAX_BUFFERED_EVENTS) this.queue.shift();
+      this.queue.push(event);
+    }
+    this.trimText();
+    this.notify();
+  }
+  shift() {
+    return this.queue.shift();
+  }
+  clear(executionId) {
+    if (executionId === void 0) this.queue.length = 0;
+    else {
+      for (let index = this.queue.length - 1; index >= 0; index -= 1) {
+        if (this.queue[index]?.executionId === executionId) this.queue.splice(index, 1);
+      }
+    }
+    this.notify();
+  }
+  clearMessage(messageId) {
+    for (let index = this.queue.length - 1; index >= 0; index -= 1) {
+      const event = this.queue[index];
+      if (event?.kind === "message_delta" && event.messageId === messageId) this.queue.splice(index, 1);
+    }
+    this.notify();
+  }
+  clearTool(toolCallId) {
+    for (let index = this.queue.length - 1; index >= 0; index -= 1) {
+      const event = this.queue[index];
+      if (event?.kind === "tool_progress" && event.toolCallId === toolCallId) this.queue.splice(index, 1);
+    }
+    this.notify();
+  }
+  checkpoint() {
+    return this.version;
+  }
+  changed(since) {
+    if (this.version !== since || this.queue.length > 0 || this.stopped) return Promise.resolve();
+    return this.wake.promise;
+  }
+  stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.queue.length = 0;
+    this.notify();
+  }
+  notify() {
+    const wake = this.wake;
+    this.wake = deferred();
+    this.version += 1;
+    wake.resolve();
+  }
+  trimText() {
+    let buffered = this.queue.reduce(
+      (length, event) => length + (event.kind === "message_delta" ? event.text.length : 0),
+      0
+    );
+    while (buffered > MAX_BUFFERED_TEXT) {
+      const index = this.queue.findIndex((event2) => event2.kind === "message_delta");
+      if (index < 0) return;
+      const event = this.queue[index];
+      const overflow = buffered - MAX_BUFFERED_TEXT;
+      if (event.text.length <= overflow) {
+        this.queue.splice(index, 1);
+        buffered -= event.text.length;
+      } else {
+        this.queue[index] = {
+          ...event,
+          offset: event.offset + overflow,
+          text: event.text.slice(overflow)
+        };
+        buffered -= overflow;
+      }
+    }
+  }
+};
+var TransientRunEventHub = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  subscribe(runId) {
+    const subscription = new TransientRunEventSubscription();
+    const current = this.subscriptions.get(runId) ?? /* @__PURE__ */ new Set();
+    current.add(subscription);
+    this.subscriptions.set(runId, current);
+    return subscription;
+  }
+  unsubscribe(runId, subscription) {
+    subscription.stop();
+    const current = this.subscriptions.get(runId);
+    current?.delete(subscription);
+    if (current?.size === 0) this.subscriptions.delete(runId);
+  }
+  publish(event) {
+    for (const subscription of this.subscriptions.get(event.runId) ?? []) {
+      subscription.push(event);
+    }
+  }
+  clear(runId, executionId) {
+    for (const subscription of this.subscriptions.get(runId) ?? []) {
+      subscription.clear(executionId);
+    }
+  }
+  clearMessage(runId, messageId) {
+    for (const subscription of this.subscriptions.get(runId) ?? []) subscription.clearMessage(messageId);
+  }
+  clearTool(runId, toolCallId) {
+    for (const subscription of this.subscriptions.get(runId) ?? []) subscription.clearTool(toolCallId);
+  }
+  close() {
+    for (const subscriptions of this.subscriptions.values()) {
+      for (const subscription of subscriptions) subscription.stop();
+    }
+    this.subscriptions.clear();
+  }
+};
+
 // src/runtime/durable-runtime.ts
 var DEFAULT_CONCURRENCY = 10;
 var DEFAULT_POLL_MS = 25;
@@ -3636,6 +3826,7 @@ var AgentRuntime = class _AgentRuntime {
   activeAgents = /* @__PURE__ */ new Set();
   executions = /* @__PURE__ */ new Map();
   consumers = /* @__PURE__ */ new Map();
+  transientEvents = new TransientRunEventHub();
   heartbeat;
   pumping = false;
   closed = false;
@@ -3693,7 +3884,7 @@ var AgentRuntime = class _AgentRuntime {
     if (input.signal.aborted) throw abortError();
     if (this.consumers.has(input.consumerId)) throw new RuntimeError("consumer_already_active", { consumerId: input.consumerId });
     const controller = new AbortController();
-    const subscription = { consumerId: input.consumerId, controller, input, caughtUp: deferred(), done: deferred() };
+    const subscription = { consumerId: input.consumerId, controller, input, caughtUp: deferred2(), done: deferred2() };
     this.consumers.set(input.consumerId, subscription);
     const onAbort = () => controller.abort();
     input.signal.addEventListener("abort", onAbort, { once: true });
@@ -3710,8 +3901,9 @@ var AgentRuntime = class _AgentRuntime {
     if (this.closed) return;
     this.closed = true;
     if (this.heartbeat) clearInterval(this.heartbeat);
-    for (const controller of this.executions.values()) controller.abort();
+    for (const execution of this.executions.values()) execution.controller.abort();
     this.executions.clear();
+    this.transientEvents.close();
     for (const subscription of this.consumers.values()) subscription.controller.abort();
     await this.owned.sealAndReleaseOwner();
   }
@@ -3732,7 +3924,9 @@ var AgentRuntime = class _AgentRuntime {
     this.assertOpen();
     const snapshot = await this.owned.snapshotRun(runId);
     await this.owned.cancelRun({ runId, expectedRevision: snapshot.revision, ...reason === void 0 ? {} : { reason } });
-    this.executions.get(runId)?.abort();
+    const active = this.executions.get(runId);
+    if (active) this.transientEvents.clear(runId, active.executionId);
+    active?.controller.abort();
     return boundaryFromSnapshot(await this.owned.snapshotRun(runId));
   }
   async pump() {
@@ -3745,6 +3939,8 @@ var AgentRuntime = class _AgentRuntime {
         if (!next) return;
         this.activeAgents.add(next.agentId);
         const task = this.execute(next).finally(() => {
+          const execution = this.executions.get(next.id);
+          if (execution) this.transientEvents.clear(next.id, execution.executionId);
           this.activeAgents.delete(next.agentId);
           this.executions.delete(next.id);
           void this.pump();
@@ -3783,7 +3979,7 @@ var AgentRuntime = class _AgentRuntime {
       const executionId = createId("exec");
       claim = await this.owned.claimRun({ runId: run.id, expectedRevision: run.revision, executionId, configToken: token });
       const controller = new AbortController();
-      this.executions.set(run.id, controller);
+      this.executions.set(run.id, { controller, executionId });
       const config = resolution.config;
       const assembly = await assembleExtensions(config);
       const executionConfig = {
@@ -3811,6 +4007,11 @@ var AgentRuntime = class _AgentRuntime {
       const result = await executeOnce({
         canonicalMessages: executionContext.messages,
         context: executionContext,
+        execution: {
+          agentId: run.agentId,
+          runId: run.id,
+          executionId: claim.execution.executionId
+        },
         model,
         stream,
         maxAttempts: executionConfig.maxAttempts,
@@ -3819,20 +4020,49 @@ var AgentRuntime = class _AgentRuntime {
         beforePhase: assembly.beforePhase,
         afterPhase: assembly.afterPhase,
         beforePrompt: assembly.beforePrompt,
+        onMessageDelta: (event) => {
+          const active = this.executions.get(run.id);
+          if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
+          this.transientEvents.publish({
+            kind: "message_delta",
+            durability: "transient",
+            runId: run.id,
+            executionId: claim.execution.executionId,
+            messageId: event.messageId,
+            offset: event.offset,
+            text: event.text
+          });
+        },
         onContext: assembly.setContext,
         runtime: {
           tools: ({ toolCall }) => {
             const task = toolQueue.then(async () => {
-              const execution = await this.executeTool({
+              const execution = await this.executeToolBatch({
+                run,
+                execution: claim.execution,
+                expectedRevision: executionRevision,
+                config: executionConfig,
+                toolCalls: [toolCall],
+                signal: controller.signal
+              });
+              executionRevision = execution.revision;
+              return execution.results[0];
+            });
+            toolQueue = task.then(() => void 0, () => void 0);
+            return task;
+          },
+          toolsBatch: ({ toolCalls }) => {
+            const task = toolQueue.then(async () => {
+              const execution = await this.executeToolBatch({
                 run,
                 execution: claim.execution,
                 expectedRevision: executionRevision,
                 config: executionConfig,
-                toolCall,
+                toolCalls,
                 signal: controller.signal
               });
               executionRevision = execution.revision;
-              return execution.result;
+              return execution.results;
             });
             toolQueue = task.then(() => void 0, () => void 0);
             return task;
@@ -3842,15 +4072,18 @@ var AgentRuntime = class _AgentRuntime {
       if (result.type === "input_required") {
         const prompt = promptMessage(run, result.request.prompt, result.messages.length);
         await this.owned.commitInputRequired({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, requestId: createId("input"), prompt, checkpoint: result.checkpoint });
+        this.transientEvents.clear(run.id, claim.execution.executionId);
         return;
       }
       if (result.type === "completed") {
         const output = latestAssistant(run, result.messages, claim.history.length);
         await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, outcome: durableOutcome(result.outcome), ...output ? { output } : {} });
+        this.transientEvents.clear(run.id, claim.execution.executionId);
         return;
       }
       const failure = { code: "execution_failed", message: result.error instanceof Error ? result.error.message : "Execution failed." };
       await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, failure });
+      this.transientEvents.clear(run.id, claim.execution.executionId);
     } catch (error) {
       if (!claim && error instanceof RuntimeError && ["run_state_conflict", "runtime_ownership_lost", "run_not_found"].includes(error.code)) return;
       if (claim) {
@@ -3871,29 +4104,75 @@ var AgentRuntime = class _AgentRuntime {
     });
   }
   async executeTool(input) {
-    const tool = input.config.context.tools.find((candidate) => candidate.name === input.toolCall.name);
-    const providerToolCallId = input.toolCall.id;
-    const toolCallId = createId("tool");
-    const requestMessageId = createId("msg");
-    const reserved = await this.owned.reserveToolCall({
+    const batch = await this.executeToolBatch({ ...input, toolCalls: [input.toolCall] });
+    return { result: batch.results[0], revision: batch.revision };
+  }
+  async executeToolBatch(input) {
+    const reserved = await this.owned.reserveToolCalls({
       runId: input.run.id,
       execution: input.execution,
       expectedRevision: input.expectedRevision,
-      requestMessageId,
-      toolCallId,
-      name: input.toolCall.name,
-      args: toJsonValue(input.toolCall.args)
+      requestMessageId: createId("msg"),
+      calls: input.toolCalls.map((toolCall) => ({
+        providerToolCallId: toolCall.id,
+        name: toolCall.name,
+        args: toJsonValue(toolCall.args)
+      }))
     });
     let revision = reserved.run.revision;
+    const results = [];
+    for (let index = 0; index < input.toolCalls.length; index += 1) {
+      const toolCall = input.toolCalls[index];
+      const tool = reserved.toolCalls[index];
+      const execution = await this.executeReservedTool({
+        ...input,
+        toolCall,
+        tool,
+        expectedRevision: revision
+      });
+      revision = execution.revision;
+      results.push(execution.result);
+    }
+    return { results, revision };
+  }
+  async executeReservedTool(input) {
+    const durableTool = input.config.context.tools.find((candidate) => candidate.name === input.toolCall.name);
+    const providerToolCallId = input.toolCall.id;
+    const toolCallId = input.tool.id;
+    let revision = input.expectedRevision;
     const protocolFailure = (error) => ({ toolCallId: providerToolCallId, toolName: input.toolCall.name, ok: false, content: null, error });
-    if (!tool) {
+    if (!durableTool) {
       const failed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: "failed", result: { ok: false, content: null, error: `Tool ${input.toolCall.name} is not available.` } });
       return { result: protocolFailure(`Tool ${input.toolCall.name} is not available.`), revision: failed.run.revision };
     }
-    const context = { agentId: input.run.agentId, runId: input.run.id, toolCallId };
+    let progressActive = false;
+    const context = {
+      agentId: input.run.agentId,
+      runId: input.run.id,
+      toolCallId,
+      reportProgress: (progress) => {
+        const active = this.executions.get(input.run.id);
+        if (!progressActive || this.closed || input.signal.aborted || active?.executionId !== input.execution.executionId || !isJsonValue(progress)) return;
+        let copy;
+        try {
+          if (JSON.stringify(progress).length > 64 * 1024) return;
+          copy = structuredClone(progress);
+        } catch {
+          return;
+        }
+        this.transientEvents.publish({
+          kind: "tool_progress",
+          durability: "transient",
+          runId: input.run.id,
+          executionId: input.execution.executionId,
+          toolCallId,
+          progress: copy
+        });
+      }
+    };
     try {
       if (input.config.beforeToolCall) {
-        const decision = await input.config.beforeToolCall({ tool, args: toJsonValue(input.toolCall.args), context, signal: input.signal });
+        const decision = await input.config.beforeToolCall({ tool: durableTool, args: toJsonValue(input.toolCall.args), context, signal: input.signal });
         if (!decision.allow) {
           const failed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: "failed", result: { ok: false, content: null, error: decision.reason } });
           return { result: protocolFailure(decision.reason), revision: failed.run.revision };
@@ -3906,10 +4185,11 @@ var AgentRuntime = class _AgentRuntime {
     }
     const started = await this.owned.startToolCall({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId });
     revision = started.run.revision;
+    progressActive = true;
     try {
-      let result = await tool.execute(toJsonValue(input.toolCall.args), context, input.signal);
+      let result = await durableTool.execute(toJsonValue(input.toolCall.args), context, input.signal);
       assertToolExecutionResult(result);
-      if (input.config.afterToolCall) result = await input.config.afterToolCall({ tool, result, context, signal: input.signal });
+      if (input.config.afterToolCall) result = await input.config.afterToolCall({ tool: durableTool, result, context, signal: input.signal });
       assertToolExecutionResult(result);
       const committed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: result.ok ? "completed" : "failed", result });
       return {
@@ -3920,6 +4200,9 @@ var AgentRuntime = class _AgentRuntime {
       const reason = error instanceof Error ? error.message : "Tool execution outcome is indeterminate.";
       const indeterminate = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: "indeterminate", reason, result: { ok: false, content: null, error: reason } });
       return { result: protocolFailure(reason), revision: indeterminate.run.revision };
+    } finally {
+      progressActive = false;
+      this.transientEvents.clearTool(input.run.id, toolCallId);
     }
   }
   async requireAgent(agentId) {
@@ -3963,23 +4246,37 @@ var AgentRuntime = class _AgentRuntime {
   }
   async *observe(runId, options = {}) {
     let cursor = options.after;
-    while (true) {
-      if (options.signal?.aborted) throw abortError();
-      const snapshot = await this.owned.snapshotRun(runId);
-      if (["completed", "failed", "cancelled"].includes(snapshot.state)) {
-        const pending = await this.owned.listEvents(cursor ? { after: cursor } : {});
-        if (!pending.some((event) => event.runId === runId)) return;
-      }
-      const events = await this.owned.listEvents(cursor ? { after: cursor } : {});
-      let terminal = false;
-      for (const event of events) {
-        cursor = event.cursor;
-        if (event.runId !== runId) continue;
-        yield event;
-        if (event.kind === "run_transitioned" && ["completed", "failed", "cancelled"].includes(event.to)) terminal = true;
+    const subscription = this.transientEvents.subscribe(runId);
+    try {
+      while (true) {
+        if (options.signal?.aborted) throw abortError();
+        const observationVersion = subscription.checkpoint();
+        const snapshot = await this.owned.snapshotRun(runId);
+        if (["completed", "failed", "cancelled"].includes(snapshot.state)) {
+          const pending = await this.owned.listEvents(cursor ? { after: cursor } : {});
+          if (!pending.some((event) => event.runId === runId)) return;
+        }
+        const events = await this.owned.listEvents(cursor ? { after: cursor } : {});
+        for (const event of events) {
+          cursor = event.cursor;
+          if (event.runId !== runId) continue;
+          if (event.kind === "message_committed") {
+            subscription.clearMessage(event.message.id);
+          } else if (event.kind === "tool_state_changed" && ["completed", "failed", "indeterminate"].includes(event.transition.to)) {
+            subscription.clearTool(event.toolCall.id);
+          }
+          yield event;
+          if (event.kind === "run_transitioned" && ["completed", "failed", "cancelled"].includes(event.to)) return;
+        }
+        const transient = subscription.shift();
+        if (transient) {
+          yield transient;
+          continue;
+        }
+        await Promise.race([subscription.changed(observationVersion), delay(DEFAULT_POLL_MS)]);
       }
-      if (terminal) return;
-      await delay(DEFAULT_POLL_MS);
+    } finally {
+      this.transientEvents.unsubscribe(runId, subscription);
     }
   }
   async wait(runId, options = {}) {
@@ -3996,7 +4293,7 @@ var AgentRuntime = class _AgentRuntime {
   startHeartbeat() {
     this.heartbeat = setInterval(() => {
       void this.owned.renewOwner(OWNER_LEASE_MS).catch(() => {
-        for (const controller of this.executions.values()) controller.abort();
+        for (const execution of this.executions.values()) execution.controller.abort();
       });
     }, OWNER_RENEWAL_MS);
     this.heartbeat.unref?.();
@@ -4070,7 +4367,7 @@ function toJsonValue(value) {
   assertJsonValue(value, "tool arguments");
   return value;
 }
-function deferred() {
+function deferred2() {
   let resolve6;
   let reject;
   const promise = new Promise((res, rej) => {
@@ -4404,54 +4701,91 @@ var InMemoryStore = class _InMemoryStore {
     return result;
   }
   reserveToolCall(lease, input) {
+    const providerToolCallId = input.providerToolCallId ?? (input.toolCallId ? String(input.toolCallId) : createId("provider"));
+    const result = this.reserveToolCalls(lease, {
+      runId: input.runId,
+      execution: input.execution,
+      expectedRevision: input.expectedRevision,
+      requestMessageId: input.requestMessageId,
+      calls: [{
+        providerToolCallId,
+        name: input.name,
+        args: input.args,
+        ...input.toolCallId === void 0 ? {} : { toolCallId: input.toolCallId }
+      }]
+    });
+    return { run: result.run, toolCall: result.toolCalls[0] };
+  }
+  reserveToolCalls(lease, input) {
     this.assertOwner(lease);
-    assertToolValue(input.args, "tool.args");
-    const toolCallId = input.toolCallId ?? createId("tool");
-    const operationKey = `tool_reserve:${toolCallId}`;
+    if (input.calls.length === 0) throw new TypeError("calls must be non-empty");
+    const providerIds = /* @__PURE__ */ new Set();
+    const durableIds = /* @__PURE__ */ new Set();
+    for (const call of input.calls) {
+      if (call.providerToolCallId.trim().length === 0) throw new TypeError("providerToolCallId must be non-empty");
+      if (providerIds.has(call.providerToolCallId)) throw new TypeError("Tool provider IDs must be unique within one response");
+      providerIds.add(call.providerToolCallId);
+      assertToolValue(call.args, "tool.args");
+      if (call.toolCallId !== void 0) {
+        if (durableIds.has(call.toolCallId)) throw new TypeError("Tool Call IDs must be unique within one response");
+        durableIds.add(call.toolCallId);
+      }
+    }
+    const operationKey = `tool_reserve_batch:${input.requestMessageId}`;
     const operationPayload = canonicalJson([
       input.runId,
       input.expectedRevision,
       input.execution.executionId,
       input.requestMessageId,
-      input.name,
-      input.args
+      input.calls
     ]);
     const replay = this.replayOperation(operationKey, operationPayload);
     if (replay) return clone(replay);
     const run = this.requireRun(input.runId);
     this.assertExecution(run, input.execution, input.expectedRevision);
-    const existing = this.toolCalls.get(toolCallId);
-    if (existing) throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
+    if (this.messages.has(input.requestMessageId)) throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
     const timestamp = createTimestamp();
-    const toolCall = {
-      id: toolCallId,
+    const toolCalls = input.calls.map((call) => ({
+      id: call.toolCallId ?? createId("tool"),
+      providerToolCallId: call.providerToolCallId,
       agentId: run.agentId,
       runId: run.id,
       executionId: input.execution.executionId,
       requestMessageId: input.requestMessageId,
-      name: input.name,
-      args: clone(input.args),
+      name: call.name,
+      args: clone(call.args),
       state: "pending",
       createdAt: timestamp,
       updatedAt: timestamp
-    };
+    }));
+    for (const toolCall of toolCalls) {
+      if (this.toolCalls.has(toolCall.id)) throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
+    }
     const requestMessage = {
       id: input.requestMessageId,
       agentId: run.agentId,
       runId: run.id,
       role: "assistant",
-      content: [{ type: "tool_use", toolCallId, name: input.name, input: clone(input.args) }],
+      content: toolCalls.map((toolCall) => ({
+        type: "tool_use",
+        toolCallId: toolCall.id,
+        providerToolCallId: toolCall.providerToolCallId,
+        name: toolCall.name,
+        input: clone(toolCall.args)
+      })),
       sequenceWithinRun: this.nextMessageSequence(run.id),
       createdAt: timestamp
     };
-    if (this.messages.has(requestMessage.id)) throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
-    this.toolCalls.set(toolCall.id, toolCall);
+    for (const toolCall of toolCalls) this.toolCalls.set(toolCall.id, toolCall);
     this.messages.set(requestMessage.id, requestMessage);
     run.revision += 1;
     run.updatedAt = timestamp;
     this.appendMessage(run, requestMessage);
-    this.appendToolTransition(run, { from: null, to: "pending" }, toolCall);
-    const result = { run: clone(run), toolCall: clone(toolCall) };
+    for (const toolCall of toolCalls) this.appendToolTransition(run, { from: null, to: "pending" }, toolCall);
+    const result = {
+      run: clone(run),
+      toolCalls: toolCalls.map((toolCall) => clone(toolCall))
+    };
     this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
   }
@@ -4500,7 +4834,7 @@ var InMemoryStore = class _InMemoryStore {
       agentId: run.agentId,
       runId: run.id,
       role: "tool",
-      content: [{ type: "tool_result", toolCallId: toolCall.id, result: clone(input.result) }],
+      content: [{ type: "tool_result", toolCallId: toolCall.id, providerToolCallId: toolCall.providerToolCallId, result: clone(input.result) }],
       sequenceWithinRun: this.nextMessageSequence(run.id),
       createdAt: createTimestamp()
     };
@@ -4660,6 +4994,9 @@ var InMemoryStore = class _InMemoryStore {
   listEvents(lease, input = {}) {
     this.assertOwner(lease);
     const after = input.after ? this.parseCursor(input.after) : 0;
+    if (after > this.eventSequence) {
+      throw new RuntimeError("invalid_cursor", { cursorType: "event", reason: "beyond_waterline" });
+    }
     return clone(this.events.filter((event) => this.parseCursor(event.cursor) > after));
   }
   openConsumer(lease, consumerId) {
@@ -4730,7 +5067,7 @@ var InMemoryStore = class _InMemoryStore {
       agentId: run.agentId,
       runId: run.id,
       role: "tool",
-      content: [{ type: "tool_result", toolCallId: toolCall.id, result }],
+      content: [{ type: "tool_result", toolCallId: toolCall.id, providerToolCallId: toolCall.providerToolCallId, result }],
       sequenceWithinRun: this.nextMessageSequence(run.id),
       createdAt: createTimestamp()
     };
@@ -4865,6 +5202,9 @@ var MemoryOwnedStore = class {
   async reserveToolCall(input) {
     return this.store.reserveToolCall(this.lease, input);
   }
+  async reserveToolCalls(input) {
+    return this.store.reserveToolCalls(this.lease, input);
+  }
   async startToolCall(input) {
     return this.store.startToolCall(this.lease, input);
   }
@@ -5118,6 +5458,9 @@ var SqliteStore = class {
   async reserveToolCall(lease, input) {
     return this.invoke(lease, (store, current) => store.reserveToolCall(current, input));
   }
+  async reserveToolCalls(lease, input) {
+    return this.invoke(lease, (store, current) => store.reserveToolCalls(current, input));
+  }
   async startToolCall(lease, input) {
     return this.invoke(lease, (store, current) => store.startToolCall(current, input));
   }
@@ -5367,6 +5710,9 @@ var SqliteOwnedStore = class {
   reserveToolCall(input) {
     return this.store.reserveToolCall(this.lease, input);
   }
+  reserveToolCalls(input) {
+    return this.store.reserveToolCalls(this.lease, input);
+  }
   startToolCall(input) {
     return this.store.startToolCall(this.lease, input);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rowan-agent/agent",
-  "version": "0.7.5",
+  "version": "0.8.0",
   "license": "MIT",
   "repository": {
     "type": "git",