@pikku/assistant-ui 0.12.0 → 0.12.1

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

@@ -1,8 +1,385 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertDbMessages = exports.usePikkuApproval = exports.PikkuApprovalContext = void 0;
+exports.isDeniedResult = isDeniedResult;
+exports.resolvePikkuToolStatus = resolvePikkuToolStatus;
 exports.usePikkuAgentRuntime = usePikkuAgentRuntime;
+exports.usePikkuAgentNonStreamingRuntime = usePikkuAgentNonStreamingRuntime;
 const react_1 = require("react");
-const react_data_stream_1 = require("@assistant-ui/react-data-stream");
+const react_2 = require("@assistant-ui/react");
+exports.PikkuApprovalContext = (0, react_1.createContext)({
+    pendingApprovals: [],
+    handleApproval: () => { },
+});
+const usePikkuApproval = () => (0, react_1.useContext)(exports.PikkuApprovalContext);
+exports.usePikkuApproval = usePikkuApproval;
+function parseSSEStream(reader) {
+    return __asyncGenerator(this, arguments, function* parseSSEStream_1() {
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = yield __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 yield __await(JSON.parse(data));
+                        }
+                        catch (_a) {
+                            // 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.
+ */
+function processStream(reader, text, toolCalls, yieldContent, onFinish) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const pendingApprovals = [];
+        try {
+            for (var _d = true, _e = __asyncValues(parseSSEStream(reader)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const event = _c;
+                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 (_g) {
+                                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 'approval-request':
+                        pendingApprovals.push({
+                            toolCallId: event.toolCallId,
+                            toolName: event.toolName,
+                            args: event.args,
+                            reason: event.reason,
+                            runId: event.runId,
+                        });
+                        break;
+                    case 'error':
+                        text.value += `\n\nError: ${event.message || event.errorText || 'Unknown error'}`;
+                        break;
+                    case 'done':
+                        onFinish === null || onFinish === void 0 ? void 0 : onFinish();
+                        continue;
+                }
+                yieldContent();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return pendingApprovals;
+    });
+}
+function isDeniedResult(result) {
+    if (result == null)
+        return false;
+    try {
+        const parsed = typeof result === 'string' ? JSON.parse(result) : result;
+        return parsed && typeof parsed === 'object' && parsed.approved === false;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function resolvePikkuToolStatus(status, result) {
+    if (status.type === 'running')
+        return { type: 'running' };
+    if (status.type === 'requires-action')
+        return { type: 'requires-action' };
+    if (isDeniedResult(result))
+        return { type: 'denied' };
+    if (typeof result === 'string' && result.startsWith('Error:'))
+        return { type: 'error' };
+    return { type: 'completed' };
+}
+function buildContent(text, toolCalls) {
+    const content = [];
+    if (text.value)
+        content.push({ type: 'text', text: text.value });
+    content.push(...toolCalls);
+    return content;
+}
+function createPikkuStreamingAdapter(optionsRef, pendingApprovalsRef, approvalDecisionsRef, setPendingApprovalsRef, onFinishRef) {
+    return {
+        run(_a) {
+            return __asyncGenerator(this, arguments, function* run_1({ messages, abortSignal }) {
+                var _b, _c, _d, _e;
+                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 yield __await(void 0);
+                    }
+                    // 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 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 = (_b = matchingApproval === null || matchingApproval === void 0 ? void 0 : matchingApproval.runId) !== null && _b !== void 0 ? _b : (_c = pendingApprovals[0]) === null || _c === void 0 ? void 0 : _c.runId;
+                        const resumeResponse = yield __await(fetch(`${opts.api}/${opts.agentName}/resume`, {
+                            method: 'POST',
+                            headers: Object.assign({ '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
+                                ? yield __await(resumeResponse.text().catch(() => ''))
+                                : '';
+                            throw new Error(`Resume failed: ${resumeResponse.status}${errorText ? ` - ${errorText}` : ''}`);
+                        }
+                        const text = { value: '' };
+                        const toolCalls = [];
+                        const reader = resumeResponse.body.getReader();
+                        const streamApprovals = yield __await(processStream(reader, text, toolCalls, () => { }, i === decisions.length - 1
+                            ? ((_d = onFinishRef.current) !== null && _d !== void 0 ? _d : undefined)
+                            : undefined)
+                        // Keep the last resume's output (it has continuation content)
+                        );
+                        // Keep the last resume's output (it has continuation content)
+                        lastText = text;
+                        lastToolCalls = toolCalls;
+                        if (streamApprovals.length > 0) {
+                            nextApprovals = streamApprovals;
+                        }
+                    }
+                    // Build content from the last resume's output
+                    const content = buildContent(lastText, 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: Object.assign(Object.assign({}, (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 = buildContent(lastText, lastToolCalls);
+                        yield yield __await({
+                            content: updatedContent,
+                            status: {
+                                type: 'requires-action',
+                                reason: 'tool-calls',
+                            },
+                        });
+                    }
+                    else if (content.length > 0) {
+                        yield yield __await({ content });
+                    }
+                    return yield __await(void 0);
+                }
+                // Normal flow: new user message → stream
+                const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user');
+                if (!lastUserMsg)
+                    return yield __await(void 0);
+                let messageText = '';
+                if (lastUserMsg.content) {
+                    for (const part of lastUserMsg.content) {
+                        if ('text' in part && part.type === 'text') {
+                            messageText += part.text;
+                        }
+                    }
+                }
+                const response = yield __await(fetch(`${opts.api}/${opts.agentName}/stream`, {
+                    method: 'POST',
+                    headers: Object.assign({ '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,
+                    }),
+                    signal: abortSignal,
+                    credentials: opts.credentials,
+                }));
+                if (!response.ok || !response.body) {
+                    throw new Error(`Agent stream failed: ${response.status}`);
+                }
+                const text = { value: '' };
+                const toolCalls = [];
+                let pendingContent = null;
+                const yieldContent = () => {
+                    const content = buildContent(text, toolCalls);
+                    if (content.length > 0)
+                        pendingContent = content;
+                };
+                const reader = response.body.getReader();
+                const approvals = yield __await(processStream(reader, text, toolCalls, yieldContent, (_e = onFinishRef.current) !== null && _e !== void 0 ? _e : undefined));
+                if (approvals.length === 0) {
+                    // No approval needed — yield final content and done
+                    if (pendingContent) {
+                        yield yield __await({ content: pendingContent });
+                    }
+                    return yield __await(void 0);
+                }
+                // 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: Object.assign(Object.assign({}, (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 = buildContent(text, toolCalls);
+                yield yield __await({
+                    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.
+                );
+                // 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.
+            });
+        },
+    };
+}
 const convertDbMessages = (dbMessages) => {
     const result = [];
     let currentAssistant = null;
@@ -96,68 +473,217 @@ const convertDbMessages = (dbMessages) => {
     }
     return result;
 };
+exports.convertDbMessages = convertDbMessages;
 function usePikkuAgentRuntime(options) {
-    const { api, threadId = null, initialMessages: rawInitialMessages, onThreadCreated, onFinish, onApprovalRequest, credentials, headers, } = options;
-    const threadIdRef = (0, react_1.useRef)(threadId);
-    threadIdRef.current = threadId;
-    const justCreatedThreadRef = (0, react_1.useRef)(false);
-    const bodyFn = (0, react_1.useCallback)(() => {
-        let currentThreadId = threadIdRef.current;
-        if (!currentThreadId) {
-            currentThreadId = crypto.randomUUID();
-            justCreatedThreadRef.current = true;
-            onThreadCreated === null || onThreadCreated === void 0 ? void 0 : onThreadCreated(currentThreadId);
-        }
-        return { threadId: currentThreadId };
-    }, [onThreadCreated]);
-    const onData = (0, react_1.useCallback)((event) => {
-        if (event.name === 'approval-request') {
-            const approval = event.data;
-            onApprovalRequest === null || onApprovalRequest === void 0 ? void 0 : onApprovalRequest({
-                toolCallId: approval.toolCallId,
+    const [pendingApprovals, setPendingApprovals] = (0, react_1.useState)([]);
+    const optionsRef = (0, react_1.useRef)(options);
+    optionsRef.current = options;
+    const onFinishRef = (0, react_1.useRef)(options.onFinish);
+    onFinishRef.current = options.onFinish;
+    const pendingApprovalsRef = (0, react_1.useRef)([]);
+    const approvalDecisionsRef = (0, react_1.useRef)([]);
+    const setPendingApprovalsRef = (0, react_1.useRef)(setPendingApprovals);
+    setPendingApprovalsRef.current = setPendingApprovals;
+    const adapter = (0, react_1.useMemo)(() => createPikkuStreamingAdapter(optionsRef, pendingApprovalsRef, approvalDecisionsRef, setPendingApprovalsRef, onFinishRef), []);
+    const initialMessages = (0, react_1.useMemo)(() => options.initialMessages
+        ? (0, exports.convertDbMessages)(options.initialMessages)
+        : undefined, [options.initialMessages]);
+    const runtime = (0, react_2.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 = (0, react_1.useCallback)((toolCallId, approved) => {
+        approvalDecisionsRef.current.push({ toolCallId, approved });
+    }, []);
+    const isAwaitingApproval = pendingApprovals.length > 0;
+    return {
+        runtime,
+        pendingApprovals,
+        isAwaitingApproval,
+        handleApproval,
+    };
+}
+function createPikkuNonStreamingAdapter(optionsRef, pendingApprovalsRef, approvalDecisionsRef, setPendingApprovalsRef, onFinishRef) {
+    return {
+        run(_a) {
+            return __asyncGenerator(this, arguments, function* run_2({ messages, abortSignal }) {
+                var _b, _c, _d, _e, _f;
+                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 yield __await(void 0);
+                    pendingApprovalsRef.current = [];
+                    setPendingApprovalsRef.current([]);
+                    // Resume uses SSE (same as streaming mode)
+                    let lastText = { value: '' };
+                    let lastToolCalls = [];
+                    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 = (_b = matchingApproval === null || matchingApproval === void 0 ? void 0 : matchingApproval.runId) !== null && _b !== void 0 ? _b : (_c = pendingApprovals[0]) === null || _c === void 0 ? void 0 : _c.runId;
+                        const resumeResponse = yield __await(fetch(`${opts.api}/${opts.agentName}/resume`, {
+                            method: 'POST',
+                            headers: Object.assign({ '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
+                                ? yield __await(resumeResponse.text().catch(() => ''))
+                                : '';
+                            throw new Error(`Resume failed: ${resumeResponse.status}${errorText ? ` - ${errorText}` : ''}`);
+                        }
+                        const text = { value: '' };
+                        const toolCalls = [];
+                        const reader = resumeResponse.body.getReader();
+                        const streamApprovals = yield __await(processStream(reader, text, toolCalls, () => { }, i === decisions.length - 1
+                            ? ((_d = onFinishRef.current) !== null && _d !== void 0 ? _d : undefined)
+                            : undefined));
+                        lastText = text;
+                        lastToolCalls = toolCalls;
+                        if (streamApprovals.length > 0) {
+                            nextApprovals = streamApprovals;
+                        }
+                    }
+                    const content = buildContent(lastText, 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: Object.assign(Object.assign({}, (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 = buildContent(lastText, lastToolCalls);
+                        yield yield __await({
+                            content: updatedContent,
+                            status: {
+                                type: 'requires-action',
+                                reason: 'tool-calls',
+                            },
+                        });
+                    }
+                    else if (content.length > 0) {
+                        yield yield __await({ content });
+                    }
+                    return yield __await(void 0);
+                }
+                // Normal flow: new user message → non-streaming POST
+                const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user');
+                if (!lastUserMsg)
+                    return yield __await(void 0);
+                let messageText = '';
+                if (lastUserMsg.content) {
+                    for (const part of lastUserMsg.content) {
+                        if ('text' in part && part.type === 'text') {
+                            messageText += part.text;
+                        }
+                    }
+                }
+                const response = yield __await(fetch(`${opts.api}/${opts.agentName}`, {
+                    method: 'POST',
+                    headers: Object.assign({ '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,
+                    }),
+                    signal: abortSignal,
+                    credentials: opts.credentials,
+                }));
+                if (!response.ok) {
+                    throw new Error(`Agent run failed: ${response.status}`);
+                }
+                const json = yield __await(response.json());
+                if (json.status === 'suspended' && ((_e = json.pendingApprovals) === null || _e === void 0 ? void 0 : _e.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: Object.assign(Object.assign({}, (typeof approval.args === 'object' && approval.args !== null
+                            ? approval.args
+                            : {})), (approval.reason ? { __approvalReason: approval.reason } : {})),
+                    }));
+                    const content = [];
+                    if (json.result) {
+                        content.push({ type: 'text', text: json.result });
+                    }
+                    content.push(...toolCalls);
+                    yield yield __await({
+                        content,
+                        status: {
+                            type: 'requires-action',
+                            reason: 'tool-calls',
+                        },
+                    });
+                    return yield __await(void 0);
+                }
+                // No approvals — yield complete content
+                (_f = onFinishRef.current) === null || _f === void 0 ? void 0 : _f.call(onFinishRef);
+                const content = [];
+                if (json.result) {
+                    content.push({ type: 'text', text: String(json.result) });
+                }
+                if (content.length > 0) {
+                    yield yield __await({ content });
+                }
             });
-        }
-    }, [onApprovalRequest]);
-    const onFinishCb = (0, react_1.useCallback)(() => {
-        onFinish === null || onFinish === void 0 ? void 0 : onFinish();
-    }, [onFinish]);
-    const initialMessages = (0, react_1.useMemo)(() => (rawInitialMessages ? convertDbMessages(rawInitialMessages) : []), [rawInitialMessages]);
-    const runtime = (0, react_data_stream_1.useDataStreamRuntime)({
-        api,
-        protocol: 'ui-message-stream',
-        body: bodyFn,
-        onData,
-        onFinish: onFinishCb,
-        initialMessages,
-        credentials,
-        headers,
-    });
-    const prevThreadIdRef = (0, react_1.useRef)(threadId);
-    const hasResetRef = (0, react_1.useRef)(false);
-    (0, react_1.useEffect)(() => {
-        if (prevThreadIdRef.current !== threadId) {
-            prevThreadIdRef.current = threadId;
-            if (justCreatedThreadRef.current) {
-                justCreatedThreadRef.current = false;
-                hasResetRef.current = true;
-                return;
-            }
-            hasResetRef.current = false;
-            if (rawInitialMessages) {
-                ;
-                runtime.thread.reset(convertDbMessages(rawInitialMessages));
-                hasResetRef.current = true;
-            }
-            else {
-                ;
-                runtime.thread.reset([]);
-            }
-        }
-        else if (!hasResetRef.current && rawInitialMessages) {
-            ;
-            runtime.thread.reset(convertDbMessages(rawInitialMessages));
-            hasResetRef.current = true;
-        }
-    }, [threadId, rawInitialMessages, runtime]);
-    return runtime;
+        },
+    };
+}
+function usePikkuAgentNonStreamingRuntime(options) {
+    const [pendingApprovals, setPendingApprovals] = (0, react_1.useState)([]);
+    const optionsRef = (0, react_1.useRef)(options);
+    optionsRef.current = options;
+    const onFinishRef = (0, react_1.useRef)(options.onFinish);
+    onFinishRef.current = options.onFinish;
+    const pendingApprovalsRef = (0, react_1.useRef)([]);
+    const approvalDecisionsRef = (0, react_1.useRef)([]);
+    const setPendingApprovalsRef = (0, react_1.useRef)(setPendingApprovals);
+    setPendingApprovalsRef.current = setPendingApprovals;
+    const adapter = (0, react_1.useMemo)(() => createPikkuNonStreamingAdapter(optionsRef, pendingApprovalsRef, approvalDecisionsRef, setPendingApprovalsRef, onFinishRef), []);
+    const initialMessages = (0, react_1.useMemo)(() => options.initialMessages
+        ? (0, exports.convertDbMessages)(options.initialMessages)
+        : undefined, [options.initialMessages]);
+    const runtime = (0, react_2.useLocalRuntime)(adapter, { initialMessages });
+    const handleApproval = (0, react_1.useCallback)((toolCallId, approved) => {
+        approvalDecisionsRef.current.push({ toolCallId, approved });
+    }, []);
+    const isAwaitingApproval = pendingApprovals.length > 0;
+    return {
+        runtime,
+        pendingApprovals,
+        isAwaitingApproval,
+        handleApproval,
+    };
 }