@pikku/assistant-ui 0.12.6 → 0.12.8

package/dist/esm/use-pikku-agent-runtime.js

@@ -1,140 +1,12 @@
-import { createContext, useContext, useMemo, useRef, useState, useCallback, } from 'react';
-import { useLocalRuntime, } from '@assistant-ui/react';
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
+import { HttpAgent } from '@ag-ui/client';
+import { useAgUiRuntime } from '@assistant-ui/react-ag-ui';
+import { ExportedMessageRepository, } from '@assistant-ui/react';
 export const PikkuApprovalContext = createContext({
     pendingApprovals: [],
-    handleApproval: () => { },
+    handleApproval: async () => false,
 });
 export const usePikkuApproval = () => useContext(PikkuApprovalContext);
-async function* parseSSEStream(reader) {
-    const decoder = new TextDecoder();
-    let buffer = '';
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop();
-        for (const line of lines) {
-            if (line.startsWith('data: ')) {
-                const data = line.slice(6);
-                if (data) {
-                    try {
-                        yield JSON.parse(data);
-                    }
-                    catch {
-                        // skip unparseable lines
-                    }
-                }
-            }
-        }
-    }
-}
-/**
- * Shared helper: consume an SSE stream and populate text/toolCalls.
- * Returns an array of PendingApprovals when the stream requests them, or empty when done.
- */
-async function processStream(reader, text, toolCalls, structuredParts, yieldContent, onFinish) {
-    const pendingApprovals = [];
-    for await (const event of parseSSEStream(reader)) {
-        switch (event.type) {
-            case 'text-delta':
-                text.value += event.text;
-                break;
-            case 'tool-call': {
-                let parsedArgs = event.args;
-                if (typeof event.args === 'string') {
-                    try {
-                        parsedArgs = JSON.parse(event.args);
-                    }
-                    catch {
-                        parsedArgs = {};
-                    }
-                }
-                toolCalls.push({
-                    type: 'tool-call',
-                    toolCallId: event.toolCallId,
-                    toolName: event.toolName,
-                    args: parsedArgs,
-                });
-                break;
-            }
-            case 'tool-result': {
-                // Skip tool-results that contain __approvalRequired
-                const resultObj = typeof event.result === 'object' ? event.result : null;
-                if (resultObj && '__approvalRequired' in resultObj) {
-                    break;
-                }
-                const tc = toolCalls.find((t) => t.toolCallId === event.toolCallId);
-                if (tc) {
-                    tc.result =
-                        typeof event.result === 'string'
-                            ? event.result
-                            : JSON.stringify(event.result);
-                    if (event.isError) {
-                        tc.isError = true;
-                    }
-                }
-                break;
-            }
-            case 'generative-ui': {
-                const nextPart = {
-                    type: 'generative-ui',
-                    spec: event.spec,
-                };
-                const existingIndex = structuredParts.findIndex((part) => part.type === 'generative-ui');
-                if (existingIndex === -1)
-                    structuredParts.push(nextPart);
-                else
-                    structuredParts[existingIndex] = nextPart;
-                break;
-            }
-            case 'data': {
-                const nextPart = {
-                    type: 'data',
-                    name: event.name,
-                    data: event.data,
-                };
-                const existingIndex = structuredParts.findIndex((part) => part.type === 'data' && part.name === event.name);
-                if (existingIndex === -1)
-                    structuredParts.push(nextPart);
-                else
-                    structuredParts[existingIndex] = nextPart;
-                break;
-            }
-            case 'approval-request':
-                pendingApprovals.push({
-                    toolCallId: event.toolCallId,
-                    toolName: event.toolName,
-                    args: event.args,
-                    reason: event.reason,
-                    runId: event.runId,
-                    type: 'approval-request',
-                });
-                break;
-            case 'credential-request':
-                pendingApprovals.push({
-                    toolCallId: event.toolCallId,
-                    toolName: event.toolName,
-                    args: event.args,
-                    runId: event.runId,
-                    type: 'credential-request',
-                    credentialName: event.credentialName,
-                    credentialType: event.credentialType,
-                    connectUrl: event.connectUrl,
-                });
-                break;
-            case 'error':
-                text.value += `\n\nError: ${event.message || event.errorText || 'Unknown error'}`;
-                break;
-            case 'done':
-                onFinish?.();
-                continue;
-        }
-        yieldContent();
-    }
-    return pendingApprovals;
-}
 export function isDeniedResult(result) {
     if (result == null)
         return false;
@@ -176,271 +48,6 @@ export function resolvePikkuToolStatus(status, result) {
         return { type: 'error' };
     return { type: 'completed' };
 }
-function buildRichContent(text, structuredParts, toolCalls) {
-    const content = [];
-    if (text.value)
-        content.push({ type: 'text', text: text.value });
-    content.push(...structuredParts);
-    content.push(...toolCalls);
-    return content;
-}
-function buildContentFromAgentResult(result) {
-    const content = [];
-    if (typeof result === 'string') {
-        if (result)
-            content.push({ type: 'text', text: result });
-        return content;
-    }
-    if (!result || typeof result !== 'object')
-        return content;
-    const record = result;
-    if (typeof record.text === 'string' && record.text) {
-        content.push({ type: 'text', text: record.text });
-    }
-    if (record.ui != null) {
-        content.push({ type: 'generative-ui', spec: record.ui });
-    }
-    return content;
-}
-function createPikkuStreamingAdapter(optionsRef, pendingApprovalsRef, approvalDecisionsRef, setPendingApprovalsRef, onFinishRef) {
-    return {
-        async *run({ messages, abortSignal }) {
-            const opts = optionsRef.current;
-            // Check if this run() is a continuation after approval decisions.
-            // assistant-ui calls run() again after addResult provides tool results for ALL tool calls.
-            const pendingApprovals = pendingApprovalsRef.current;
-            if (pendingApprovals.length > 0) {
-                // Read the decisions accumulated by handleApproval() from click handlers.
-                const decisions = approvalDecisionsRef.current;
-                approvalDecisionsRef.current = [];
-                if (decisions.length === 0) {
-                    // No decisions set — shouldn't happen if composer is disabled.
-                    return;
-                }
-                // Clear pending approvals state
-                pendingApprovalsRef.current = [];
-                setPendingApprovalsRef.current([]);
-                // Send /resume for each decision sequentially.
-                // All but the last resume will return quickly (just tool-result + done).
-                // The last resume triggers continuation (next LLM step).
-                let lastText = { value: '' };
-                let lastToolCalls = [];
-                let lastStructuredParts = [];
-                let nextApprovals = [];
-                for (let i = 0; i < decisions.length; i++) {
-                    const decision = decisions[i];
-                    // Find the runId from the matching pending approval
-                    const matchingApproval = pendingApprovals.find((p) => p.toolCallId === decision.toolCallId);
-                    const runId = matchingApproval?.runId ?? pendingApprovals[0]?.runId;
-                    const resumeResponse = await fetch(`${opts.api}/${opts.agentName}/resume`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            ...opts.headers,
-                        },
-                        body: JSON.stringify({
-                            runId,
-                            toolCallId: decision.toolCallId,
-                            approved: decision.approved,
-                        }),
-                        signal: abortSignal,
-                        credentials: opts.credentials,
-                    });
-                    if (!resumeResponse.ok || !resumeResponse.body) {
-                        const errorText = resumeResponse.body
-                            ? await resumeResponse.text().catch(() => '')
-                            : '';
-                        throw new Error(`Resume failed: ${resumeResponse.status}${errorText ? ` - ${errorText}` : ''}`);
-                    }
-                    const text = { value: '' };
-                    const toolCalls = [];
-                    const structuredParts = [];
-                    const reader = resumeResponse.body.getReader();
-                    const streamApprovals = await processStream(reader, text, toolCalls, structuredParts, () => { }, i === decisions.length - 1
-                        ? (onFinishRef.current ?? undefined)
-                        : undefined);
-                    // Keep the last resume's output (it has continuation content)
-                    lastText = text;
-                    lastToolCalls = toolCalls;
-                    lastStructuredParts = structuredParts;
-                    if (streamApprovals.length > 0) {
-                        nextApprovals = streamApprovals;
-                    }
-                }
-                // Build content from the last resume's output
-                const content = buildRichContent(lastText, lastStructuredParts, lastToolCalls);
-                if (nextApprovals.length > 0) {
-                    // More approvals from continuation — show them
-                    pendingApprovalsRef.current = nextApprovals;
-                    setPendingApprovalsRef.current(nextApprovals);
-                    // Add approval tool calls to content
-                    for (const approval of nextApprovals) {
-                        const approvalToolCall = {
-                            type: 'tool-call',
-                            toolCallId: approval.toolCallId,
-                            toolName: approval.toolName,
-                            args: {
-                                ...(typeof approval.args === 'object' && approval.args !== null
-                                    ? approval.args
-                                    : {}),
-                                ...(approval.reason
-                                    ? { __approvalReason: approval.reason }
-                                    : {}),
-                            },
-                        };
-                        const idx = lastToolCalls.findIndex((tc) => tc.toolCallId === approval.toolCallId && !tc.result);
-                        if (idx !== -1) {
-                            lastToolCalls[idx] = approvalToolCall;
-                        }
-                        else {
-                            lastToolCalls.push(approvalToolCall);
-                        }
-                    }
-                    const updatedContent = buildRichContent(lastText, lastStructuredParts, lastToolCalls);
-                    yield {
-                        content: updatedContent,
-                        status: {
-                            type: 'requires-action',
-                            reason: 'tool-calls',
-                        },
-                    };
-                }
-                else if (content.length > 0) {
-                    yield { content };
-                }
-                return;
-            }
-            // Normal flow: new user message → stream
-            const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user');
-            if (!lastUserMsg)
-                return;
-            let messageText = '';
-            if (lastUserMsg.content) {
-                for (const part of lastUserMsg.content) {
-                    if ('text' in part && part.type === 'text') {
-                        messageText += part.text;
-                    }
-                }
-            }
-            let response;
-            try {
-                response = await fetch(`${opts.api}/${opts.agentName}/stream`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json', ...opts.headers },
-                    body: JSON.stringify({
-                        agentName: opts.agentName,
-                        message: messageText,
-                        threadId: opts.threadId,
-                        resourceId: opts.resourceId,
-                        model: opts.model,
-                        temperature: opts.temperature,
-                        ...(opts.context ? { context: opts.context } : {}),
-                    }),
-                    signal: abortSignal,
-                    credentials: opts.credentials,
-                });
-            }
-            catch (e) {
-                const msg = e?.message || 'Unknown error';
-                let errorText = 'Failed to connect to the agent.';
-                if (msg.includes('Failed to fetch') ||
-                    msg.includes('NetworkError') ||
-                    msg.includes('CORS')) {
-                    errorText =
-                        'Unable to reach the agent server. The deployment may be down or the URL may be incorrect.';
-                }
-                else if (msg.includes('abort')) {
-                    return;
-                }
-                yield { content: [{ type: 'text', text: `⚠️ ${errorText}` }] };
-                return;
-            }
-            if (!response.ok || !response.body) {
-                let errorText = `Request failed (${response.status}).`;
-                if (response.status === 401 || response.status === 403) {
-                    errorText = 'Authentication error.';
-                }
-                else if (response.status === 404) {
-                    errorText =
-                        'Agent not found — the agent may not be configured for this project.';
-                }
-                else if (response.status === 502 || response.status === 503) {
-                    errorText =
-                        'The agent server is currently unavailable. Try again in a moment.';
-                }
-                else if (response.status === 429) {
-                    errorText = 'Rate limited — too many requests. Please wait a moment.';
-                }
-                yield { content: [{ type: 'text', text: `⚠️ ${errorText}` }] };
-                return;
-            }
-            const text = { value: '' };
-            const toolCalls = [];
-            const structuredParts = [];
-            let pendingContent = null;
-            const yieldContent = () => {
-                const content = buildRichContent(text, structuredParts, toolCalls);
-                if (content.length > 0)
-                    pendingContent = content;
-            };
-            const reader = response.body.getReader();
-            const approvals = await processStream(reader, text, toolCalls, structuredParts, yieldContent, onFinishRef.current ?? undefined);
-            if (approvals.length === 0) {
-                // No approval needed — yield final content and done
-                if (pendingContent) {
-                    yield { content: pendingContent };
-                }
-                return;
-            }
-            // Approvals requested: store them for the next run() call
-            pendingApprovalsRef.current = approvals;
-            setPendingApprovalsRef.current(approvals);
-            // Each approval tool call needs to be shown without a result
-            // so assistant-ui renders them as requires-action
-            for (const approval of approvals) {
-                const approvalToolCall = {
-                    type: 'tool-call',
-                    toolCallId: approval.toolCallId,
-                    toolName: approval.toolName,
-                    args: {
-                        ...(typeof approval.args === 'object' && approval.args !== null
-                            ? approval.args
-                            : {}),
-                        ...(approval.reason ? { __approvalReason: approval.reason } : {}),
-                    },
-                };
-                // Replace the existing tool call (if any) with the approval version
-                const parentIdx = toolCalls.findIndex((tc) => tc.toolCallId === approval.toolCallId && !tc.result);
-                if (parentIdx !== -1) {
-                    toolCalls[parentIdx] = approvalToolCall;
-                }
-                else {
-                    toolCalls.push(approvalToolCall);
-                }
-            }
-            // Remove any forwarded sub-agent tool calls that duplicate approval tool names
-            const approvalToolCallIds = new Set(approvals.map((a) => a.toolCallId));
-            const approvalToolNames = new Set(approvals.map((a) => a.toolName));
-            for (let i = toolCalls.length - 1; i >= 0; i--) {
-                if (approvalToolNames.has(toolCalls[i].toolName) &&
-                    !approvalToolCallIds.has(toolCalls[i].toolCallId)) {
-                    toolCalls.splice(i, 1);
-                }
-            }
-            const content = buildRichContent(text, structuredParts, toolCalls);
-            yield {
-                content,
-                status: {
-                    type: 'requires-action',
-                    reason: 'tool-calls',
-                },
-            };
-            // Generator returns here. assistant-ui will show the approval UI for each tool call.
-            // When the user clicks Approve/Deny on ALL tools → handleApproval accumulates decisions →
-            // addResult for each → run() is called again when all have results.
-        },
-    };
-}
 export const convertDbMessages = (dbMessages) => {
     const result = [];
     let currentAssistant = null;
@@ -542,221 +149,200 @@ export const convertDbMessages = (dbMessages) => {
     }
     return result;
 };
+function extractLastUserMessage(messages) {
+    const lastUser = [...messages].reverse().find((m) => m.role === 'user');
+    if (!lastUser)
+        return '';
+    const content = lastUser.content;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((p) => p.type === 'text')
+            .map((p) => p.text ?? '')
+            .join('');
+    }
+    return '';
+}
+class PikkuAgent extends HttpAgent {
+    pikkuOpts;
+    _pendingResume = null;
+    _currentResume = null;
+    constructor(opts) {
+        super({
+            url: `${opts.api}/${opts.agentName}/stream`,
+            threadId: opts.threadId,
+        });
+        this.pikkuOpts = opts;
+    }
+    updateOpts(opts) {
+        this.pikkuOpts = opts;
+    }
+    queueResume(data) {
+        this._pendingResume = data;
+    }
+    run(input) {
+        const resume = this._pendingResume;
+        this._pendingResume = null;
+        this._currentResume = resume;
+        this.url = resume
+            ? `${this.pikkuOpts.api}/${this.pikkuOpts.agentName}/resume`
+            : `${this.pikkuOpts.api}/${this.pikkuOpts.agentName}/stream`;
+        return super.run(input);
+    }
+    requestInit(input) {
+        const base = super.requestInit(input);
+        const resume = this._currentResume;
+        const opts = this.pikkuOpts;
+        const headers = {
+            'Content-Type': 'application/json',
+            Accept: 'text/event-stream',
+            ...opts.headers,
+        };
+        if (resume) {
+            return {
+                ...base,
+                headers,
+                credentials: opts.credentials,
+                body: JSON.stringify(resume),
+            };
+        }
+        return {
+            ...base,
+            headers,
+            credentials: opts.credentials,
+            body: JSON.stringify({
+                agentName: opts.agentName,
+                message: extractLastUserMessage(input.messages),
+                threadId: opts.threadId,
+                resourceId: opts.resourceId,
+                model: opts.model,
+                temperature: opts.temperature,
+                ...(opts.context ? { context: opts.context } : {}),
+            }),
+        };
+    }
+}
 export function usePikkuAgentRuntime(options) {
     const [pendingApprovals, setPendingApprovals] = useState([]);
-    const optionsRef = useRef(options);
-    optionsRef.current = options;
+    // Authoritative pending list, mutated synchronously so two approval clicks
+    // in the same tick can't both read a stale "remaining" and skip the resume.
+    // State mirrors it purely for rendering.
+    const pendingApprovalsRef = useRef([]);
+    const commitPending = useCallback((next) => {
+        pendingApprovalsRef.current = next;
+        setPendingApprovals(next);
+    }, []);
     const onFinishRef = useRef(options.onFinish);
     onFinishRef.current = options.onFinish;
-    const pendingApprovalsRef = useRef([]);
-    const approvalDecisionsRef = useRef([]);
-    const setPendingApprovalsRef = useRef(setPendingApprovals);
-    setPendingApprovalsRef.current = setPendingApprovals;
-    const adapter = useMemo(() => createPikkuStreamingAdapter(optionsRef, pendingApprovalsRef, approvalDecisionsRef, setPendingApprovalsRef, onFinishRef), []);
-    const initialMessages = useMemo(() => options.initialMessages
-        ? convertDbMessages(options.initialMessages)
-        : undefined, [options.initialMessages]);
-    const runtime = useLocalRuntime(adapter, { initialMessages });
-    // handleApproval is called from the Approve/Deny button click handler.
-    // It accumulates the decision in the ref. assistant-ui will call run()
-    // when ALL tool calls have results (via addResult).
-    const handleApproval = useCallback((toolCallId, approved) => {
-        approvalDecisionsRef.current.push({ toolCallId, approved });
+    const agent = useMemo(() => new PikkuAgent(options), 
+    // agent is intentionally created once; opts are synced via updateOpts
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    useEffect(() => {
+        agent.updateOpts(options);
+    });
+    useEffect(() => {
+        const { unsubscribe } = agent.subscribe({
+            onCustomEvent: ({ event }) => {
+                const e = event;
+                if (e.name === 'pikku:approval-request') {
+                    const v = e.value;
+                    commitPending([
+                        ...pendingApprovalsRef.current,
+                        {
+                            toolCallId: v.toolCallId,
+                            toolName: v.toolName,
+                            args: v.args,
+                            reason: v.reason,
+                            runId: v.runId,
+                            type: 'approval-request',
+                        },
+                    ]);
+                }
+                else if (e.name === 'pikku:credential-request') {
+                    const v = e.value;
+                    commitPending([
+                        ...pendingApprovalsRef.current,
+                        {
+                            toolCallId: v.toolCallId,
+                            toolName: v.toolName,
+                            args: v.args,
+                            runId: v.runId,
+                            type: 'credential-request',
+                            credentialName: v.credentialName,
+                            credentialType: v.credentialType,
+                            connectUrl: v.connectUrl,
+                        },
+                    ]);
+                }
+            },
+            onRunFinalized: () => {
+                onFinishRef.current?.();
+            },
+        });
+        return unsubscribe;
+    }, [agent, commitPending]);
+    // Hydrate the thread from prior messages via the AG-UI history adapter,
+    // which useAgUiRuntime loads once on mount. Built once — see the
+    // initialMessages doc note about keeping the chat unmounted until ready.
+    const history = useMemo(() => {
+        if (!options.initialMessages?.length)
+            return undefined;
+        const repository = ExportedMessageRepository.fromArray(options.initialMessages);
+        return {
+            load: async () => repository,
+            append: async () => { },
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
-    const isAwaitingApproval = pendingApprovals.length > 0;
-    return {
-        runtime,
-        pendingApprovals,
-        isAwaitingApproval,
-        handleApproval,
-    };
-}
-function createPikkuNonStreamingAdapter(optionsRef, pendingApprovalsRef, approvalDecisionsRef, setPendingApprovalsRef, onFinishRef) {
-    return {
-        async *run({ messages, abortSignal }) {
-            const opts = optionsRef.current;
-            // Continuation after approval decisions
-            const pendingApprovals = pendingApprovalsRef.current;
-            if (pendingApprovals.length > 0) {
-                const decisions = approvalDecisionsRef.current;
-                approvalDecisionsRef.current = [];
-                if (decisions.length === 0)
-                    return;
-                pendingApprovalsRef.current = [];
-                setPendingApprovalsRef.current([]);
-                // Resume uses SSE (same as streaming mode)
-                let lastText = { value: '' };
-                let lastToolCalls = [];
-                let lastStructuredParts = [];
-                let nextApprovals = [];
-                for (let i = 0; i < decisions.length; i++) {
-                    const decision = decisions[i];
-                    const matchingApproval = pendingApprovals.find((p) => p.toolCallId === decision.toolCallId);
-                    const runId = matchingApproval?.runId ?? pendingApprovals[0]?.runId;
-                    const resumeResponse = await fetch(`${opts.api}/${opts.agentName}/resume`, {
+    const runtime = useAgUiRuntime(history ? { agent, adapters: { history } } : { agent });
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    const resumeChainRef = useRef(Promise.resolve());
+    // The runtime only aggregates events from runs it starts itself, so the
+    // final approval is queued on the agent and triggered by the caller's
+    // addResult (which makes the runtime start the resume run once every tool
+    // call has a result). Earlier approvals in a batch are acknowledged with
+    // plain requests — their stream carries no content beyond 'done'.
+    const handleApproval = useCallback(async (toolCallId, approved) => {
+        const approval = pendingApprovalsRef.current.find((p) => p.toolCallId === toolCallId);
+        if (!approval || !approval.runId)
+            return false;
+        const remaining = pendingApprovalsRef.current.filter((p) => p.toolCallId !== toolCallId);
+        commitPending(remaining);
+        const resume = { runId: approval.runId, toolCallId, approved };
+        if (remaining.length > 0) {
+            resumeChainRef.current = resumeChainRef.current.then(async () => {
+                const opts = optionsRef.current;
+                try {
+                    const response = await fetch(`${opts.api}/${opts.agentName}/resume`, {
                         method: 'POST',
                         headers: {
                             'Content-Type': 'application/json',
+                            Accept: 'text/event-stream',
                             ...opts.headers,
                         },
-                        body: JSON.stringify({
-                            runId,
-                            toolCallId: decision.toolCallId,
-                            approved: decision.approved,
-                        }),
-                        signal: abortSignal,
                         credentials: opts.credentials,
+                        body: JSON.stringify(resume),
                     });
-                    if (!resumeResponse.ok || !resumeResponse.body) {
-                        const errorText = resumeResponse.body
-                            ? await resumeResponse.text().catch(() => '')
-                            : '';
-                        throw new Error(`Resume failed: ${resumeResponse.status}${errorText ? ` - ${errorText}` : ''}`);
-                    }
-                    const text = { value: '' };
-                    const toolCalls = [];
-                    const structuredParts = [];
-                    const reader = resumeResponse.body.getReader();
-                    const streamApprovals = await processStream(reader, text, toolCalls, structuredParts, () => { }, i === decisions.length - 1
-                        ? (onFinishRef.current ?? undefined)
-                        : undefined);
-                    lastText = text;
-                    lastToolCalls = toolCalls;
-                    lastStructuredParts = structuredParts;
-                    if (streamApprovals.length > 0) {
-                        nextApprovals = streamApprovals;
-                    }
+                    await response.text();
                 }
-                const content = buildRichContent(lastText, lastStructuredParts, lastToolCalls);
-                if (nextApprovals.length > 0) {
-                    pendingApprovalsRef.current = nextApprovals;
-                    setPendingApprovalsRef.current(nextApprovals);
-                    for (const approval of nextApprovals) {
-                        const approvalToolCall = {
-                            type: 'tool-call',
-                            toolCallId: approval.toolCallId,
-                            toolName: approval.toolName,
-                            args: {
-                                ...(typeof approval.args === 'object' && approval.args !== null
-                                    ? approval.args
-                                    : {}),
-                                ...(approval.reason
-                                    ? { __approvalReason: approval.reason }
-                                    : {}),
-                            },
-                        };
-                        const idx = lastToolCalls.findIndex((tc) => tc.toolCallId === approval.toolCallId && !tc.result);
-                        if (idx !== -1) {
-                            lastToolCalls[idx] = approvalToolCall;
-                        }
-                        else {
-                            lastToolCalls.push(approvalToolCall);
-                        }
-                    }
-                    const updatedContent = buildRichContent(lastText, lastStructuredParts, lastToolCalls);
-                    yield {
-                        content: updatedContent,
-                        status: {
-                            type: 'requires-action',
-                            reason: 'tool-calls',
-                        },
-                    };
+                catch (err) {
+                    console.error('[pikku] failed to resolve approval', err);
                 }
-                else if (content.length > 0) {
-                    yield { content };
-                }
-                return;
-            }
-            // Normal flow: new user message → non-streaming POST
-            const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user');
-            if (!lastUserMsg)
-                return;
-            let messageText = '';
-            if (lastUserMsg.content) {
-                for (const part of lastUserMsg.content) {
-                    if ('text' in part && part.type === 'text') {
-                        messageText += part.text;
-                    }
-                }
-            }
-            const response = await fetch(`${opts.api}/${opts.agentName}`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', ...opts.headers },
-                body: JSON.stringify({
-                    agentName: opts.agentName,
-                    message: messageText,
-                    threadId: opts.threadId,
-                    resourceId: opts.resourceId,
-                    model: opts.model,
-                    temperature: opts.temperature,
-                    ...(opts.context ? { context: opts.context } : {}),
-                }),
-                signal: abortSignal,
-                credentials: opts.credentials,
             });
-            if (!response.ok) {
-                throw new Error(`Agent run failed: ${response.status}`);
-            }
-            const json = await response.json();
-            if (json.status === 'suspended' && json.pendingApprovals?.length > 0) {
-                const approvals = json.pendingApprovals;
-                pendingApprovalsRef.current = approvals;
-                setPendingApprovalsRef.current(approvals);
-                const toolCalls = approvals.map((approval) => ({
-                    type: 'tool-call',
-                    toolCallId: approval.toolCallId,
-                    toolName: approval.toolName,
-                    args: {
-                        ...(typeof approval.args === 'object' && approval.args !== null
-                            ? approval.args
-                            : {}),
-                        ...(approval.reason ? { __approvalReason: approval.reason } : {}),
-                    },
-                }));
-                const content = [];
-                content.push(...buildContentFromAgentResult(json.result));
-                content.push(...toolCalls);
-                yield {
-                    content,
-                    status: {
-                        type: 'requires-action',
-                        reason: 'tool-calls',
-                    },
-                };
-                return;
-            }
-            // No approvals — yield complete content
-            onFinishRef.current?.();
-            const content = buildContentFromAgentResult(json.result);
-            if (content.length > 0) {
-                yield { content };
-            }
-        },
-    };
-}
-export function usePikkuAgentNonStreamingRuntime(options) {
-    const [pendingApprovals, setPendingApprovals] = useState([]);
-    const optionsRef = useRef(options);
-    optionsRef.current = options;
-    const onFinishRef = useRef(options.onFinish);
-    onFinishRef.current = options.onFinish;
-    const pendingApprovalsRef = useRef([]);
-    const approvalDecisionsRef = useRef([]);
-    const setPendingApprovalsRef = useRef(setPendingApprovals);
-    setPendingApprovalsRef.current = setPendingApprovals;
-    const adapter = useMemo(() => createPikkuNonStreamingAdapter(optionsRef, pendingApprovalsRef, approvalDecisionsRef, setPendingApprovalsRef, onFinishRef), []);
-    const initialMessages = useMemo(() => options.initialMessages
-        ? convertDbMessages(options.initialMessages)
-        : undefined, [options.initialMessages]);
-    const runtime = useLocalRuntime(adapter, { initialMessages });
-    const handleApproval = useCallback((toolCallId, approved) => {
-        approvalDecisionsRef.current.push({ toolCallId, approved });
-    }, []);
-    const isAwaitingApproval = pendingApprovals.length > 0;
+            await resumeChainRef.current;
+            return true;
+        }
+        await resumeChainRef.current;
+        agent.queueResume(resume);
+        return true;
+    }, [agent, commitPending]);
     return {
         runtime,
         pendingApprovals,
-        isAwaitingApproval,
+        isAwaitingApproval: pendingApprovals.length > 0,
         handleApproval,
     };
 }