@nanoagent/kernel 0.0.0 → 0.1.1

package/dist/index.js

@@ -227,6 +227,43 @@ async function buildModelResult(result) {
         providerMetadata
     };
 }
+function createAsyncQueue() {
+    const values = [];
+    const waiters = [];
+    let closed = false;
+    return {
+        push(value) {
+            const waiter = waiters.shift();
+            if (waiter) {
+                waiter({ done: false, value });
+                return;
+            }
+            values.push(value);
+        },
+        close() {
+            closed = true;
+            for (const waiter of waiters.splice(0)) {
+                waiter({ done: true, value: undefined });
+            }
+        },
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    if (values.length > 0) {
+                        const value = values.shift();
+                        return Promise.resolve({ done: false, value });
+                    }
+                    if (closed) {
+                        return Promise.resolve({ done: true, value: undefined });
+                    }
+                    return new Promise(resolve => {
+                        waiters.push(resolve);
+                    });
+                }
+            };
+        }
+    };
+}
 function makeBaseArgs(state) {
     const readonlyState = deepFreeze(cloneUnknown(state));
     return {
@@ -570,8 +607,8 @@ export async function* runAgent(options) {
             yield* emitEvents(modelStartedResult.events);
             return;
         }
-        const streamEvents = [];
-        const callModelResult = await Effect.runPromise(runMiddleware({
+        const streamEvents = createAsyncQueue();
+        const callModelResultPromise = Effect.runPromise(runMiddleware({
             input: {
                 ...makeBaseArgs(snapshot),
                 args: modelArgs,
@@ -591,17 +628,23 @@ export async function* runAgent(options) {
                     }),
                     catch: toError
                 }));
-                const attemptStreamEvents = [];
                 for await (const part of rawResult.fullStream) {
                     await Effect.runPromise(checkNotAborted(options.signal));
-                    attemptStreamEvents.push({
+                    const event = {
                         type: 'stream_part',
                         runId: snapshot.runId,
                         turnId: currentTurn.turnId,
                         turn: currentTurn.turn,
                         createdAt: nowIso(),
                         part
-                    });
+                    };
+                    await Effect.runPromise(fromAgentResult(() => hooks.onStreamUpdate?.({
+                        ...makeBaseArgs(snapshot),
+                        createdAt: event.createdAt,
+                        part: event.part,
+                        turn: cloneTurn(currentTurn)
+                    })));
+                    streamEvents.push(event);
                 }
                 const modelResult = cloneModelResult(await buildModelResult(rawResult));
                 const pendingToolCalls = modelResult.finishReason === 'tool-calls'
@@ -611,7 +654,6 @@ export async function* runAgent(options) {
                     }))).map(cloneToolCall)
                     : [];
                 const completedAt = nowIso();
-                streamEvents.push(...attemptStreamEvents);
                 return {
                     args: {
                         ...input.args,
@@ -623,17 +665,12 @@ export async function* runAgent(options) {
                     result: modelResult
                 };
             }
-        }));
-        const completedAt = nowIso();
-        for (const event of streamEvents) {
-            await Effect.runPromise(fromAgentResult(() => hooks.onStreamUpdate?.({
-                ...makeBaseArgs(snapshot),
-                createdAt: event.createdAt,
-                part: event.part,
-                turn: cloneTurn(currentTurn)
-            })));
-            yield* emitEvents([event]);
+        })).finally(() => streamEvents.close());
+        for await (const event of streamEvents) {
+            yield event;
         }
+        const callModelResult = await callModelResultPromise;
+        const completedAt = nowIso();
         const modelCompletedHook = await Effect.runPromise(fromAgentResult(() => hooks.onModelCompleted?.({
             ...makeBaseArgs(snapshot),
             args: callModelResult.args,
@@ -1010,16 +1047,20 @@ export async function* runAgent(options) {
             status: { type: 'failed', phase, error: failure, createdAt }
         };
         snapshot = failedSnapshot;
-        return snapshotState(failedSnapshot, [
-            {
-                type: 'run_failed',
-                runId: snapshot.runId,
-                revision: snapshot.revision,
-                createdAt,
-                phase,
-                error: failure
-            }
-        ]);
+        const runFailedEvent = {
+            type: 'run_failed',
+            runId: snapshot.runId,
+            revision: snapshot.revision,
+            createdAt,
+            phase,
+            error: failure
+        };
+        try {
+            return await snapshotState(failedSnapshot, [runFailedEvent]);
+        }
+        catch {
+            return [runFailedEvent];
+        }
     }
     try {
         await Effect.runPromise(checkNotAborted(options.signal));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanoagent/kernel",
-  "version": "0.0.0",
+  "version": "0.1.1",
   "type": "module",
   "packageManager": "bun@1.3.13",
   "publishConfig": {