@playcraft/cli 0.0.59 → 0.1.1

package/dist/workspace-runtime/codex/loopback.js

@@ -1,59 +1,140 @@
-import { nativeEvent } from './native-adapter.js';
+import { projectNativeThread } from '@playcraft/common/cloud-workspace/runtime';
+import { collectedEvent } from './native-adapter.js';
 /** In-process Codex stand-in. Not the App Server; used to prove the operation/event loop. */
 export function createLoopbackNativeAdapter() {
     const threads = new Map();
     const approvals = new Set();
+    const collected = new Set();
+    const sent = new Set();
+    let turnStarts = 0;
+    function emit(event) {
+        for (const listener of collected)
+            listener(event);
+    }
     return {
         name: 'loopback',
         ready: () => true,
+        onCollected(listener) {
+            collected.add(listener);
+            return () => collected.delete(listener);
+        },
+        turnStartSends() {
+            return turnStarts;
+        },
         async startThread(input) {
             const threadId = `thread_${input.sessionId}`;
-            threads.set(threadId, input.sessionId);
+            threads.set(threadId, { sessionId: input.sessionId, items: [] });
             return { threadId };
         },
         async startTurn(input) {
-            if (threads.get(input.threadId) !== input.sessionId) {
-                return {
-                    outcome: 'failed',
-                    events: [nativeEvent('turn.failed', { reason: 'unknown_thread' })],
-                };
-            }
-            if (input.simulateLostReceipt) {
-                return { outcome: 'uncertain', events: [] };
+            const thread = threads.get(input.threadId);
+            if (!thread || thread.sessionId !== input.sessionId)
+                return { outcome: 'failed', error: 'unknown_thread' };
+            const nativeRequestId = `loopback:${input.sessionId}:${input.clientRequestId}`;
+            const sentKey = `${input.sessionId}:${input.clientRequestId}`;
+            await input.persistReservation({ nativeRequestId });
+            if (input.simulateLostReceipt || sent.has(sentKey)) {
+                sent.add(sentKey);
+                return { outcome: 'uncertain', threadId: input.threadId };
             }
-            const turnId = `turn_${input.clientRequestId}`;
-            const events = [
-                nativeEvent('item/agentMessage/delta', { text: `loopback:${input.text}` }),
-                nativeEvent('turn.completed', { turnId, threadId: input.threadId }),
-            ];
-            if (input.text.includes('[approval]')) {
-                const approvalId = `approval_${input.clientRequestId}`;
-                approvals.add(JSON.stringify([input.sessionId, approvalId]));
-                events.splice(1, 0, nativeEvent('item/tool/requestUserInput', { approvalId }));
-                return { outcome: 'completed', turnId, approvalId, events };
+            sent.add(sentKey);
+            turnStarts += 1;
+            const turnId = `turn_${input.sessionId}_${input.clientRequestId}`;
+            thread.turnId = turnId;
+            thread.items.push({
+                type: 'userMessage',
+                id: `user_${turnId}`,
+                content: [{ type: 'text', text: input.text }],
+            });
+            if (!input.text.includes('[approval]')) {
+                thread.items.push({
+                    type: 'agentMessage',
+                    id: `agent_${turnId}`,
+                    text: `loopback:${input.text}`,
+                });
             }
-            return { outcome: 'completed', turnId, events };
+            queueMicrotask(() => {
+                emit(collectedEvent('notification', 'item/agentMessage/delta', {
+                    threadId: input.threadId,
+                    turnId,
+                    text: `loopback:${input.text}`,
+                    delta: `loopback:${input.text}`,
+                }));
+                if (input.text.includes('[approval]')) {
+                    const approvalId = `approval_${input.clientRequestId}`;
+                    approvals.add(JSON.stringify([input.sessionId, approvalId]));
+                    emit(collectedEvent('approval_request', 'item/tool/requestUserInput', {
+                        threadId: input.threadId,
+                        turnId,
+                        approvalId,
+                        itemId: approvalId,
+                    }));
+                    return;
+                }
+                emit(collectedEvent('notification', 'turn/completed', {
+                    threadId: input.threadId,
+                    turnId,
+                    turn: { id: turnId, status: 'completed' },
+                }));
+            });
+            return { outcome: 'accepted', threadId: input.threadId, turnId };
         },
         async interrupt(input) {
-            if (threads.get(input.threadId) !== input.sessionId) {
-                return { outcome: 'uncertain', events: [] };
-            }
-            return {
-                outcome: 'interrupted',
-                events: [nativeEvent('turn.interrupted', { threadId: input.threadId })],
-            };
+            const thread = threads.get(input.threadId);
+            if (!thread || thread.sessionId !== input.sessionId)
+                return { outcome: 'uncertain' };
+            const turnId = thread.turnId;
+            queueMicrotask(() => {
+                emit(collectedEvent('notification', 'turn/completed', {
+                    threadId: input.threadId,
+                    turnId,
+                    turn: { id: turnId, status: 'interrupted' },
+                }));
+            });
+            return { outcome: 'accepted', turnId };
         },
         async respondApproval(input) {
-            if (!approvals.has(JSON.stringify([input.sessionId, input.approvalId]))) {
-                return { outcome: 'failed', events: [nativeEvent('approval.unknown', { approvalId: input.approvalId })] };
+            const key = JSON.stringify([input.sessionId, input.approvalId]);
+            if (!approvals.has(key))
+                return { outcome: 'failed', approvalId: input.approvalId };
+            approvals.delete(key);
+            const thread = [...threads].find(([, value]) => value.sessionId === input.sessionId);
+            queueMicrotask(() => {
+                emit(collectedEvent('notification', 'approval.resolved', {
+                    approvalId: input.approvalId,
+                    accepted: input.accepted,
+                    threadId: thread?.[0],
+                    turnId: thread?.[1].turnId,
+                }));
+                emit(collectedEvent('notification', 'item/agentMessage/delta', {
+                    threadId: thread?.[0],
+                    turnId: thread?.[1].turnId,
+                    delta: 'after-approval',
+                }));
+                emit(collectedEvent('notification', 'turn/completed', {
+                    threadId: thread?.[0],
+                    turnId: thread?.[1].turnId,
+                    turn: { id: thread?.[1].turnId, status: 'completed' },
+                }));
+            });
+            const found = thread?.[1];
+            if (found) {
+                found.items.push({
+                    type: 'agentMessage',
+                    id: `agent_${found.turnId ?? input.approvalId}`,
+                    text: 'after-approval',
+                });
             }
-            approvals.delete(JSON.stringify([input.sessionId, input.approvalId]));
-            const result = {
-                outcome: 'completed',
-                approvalId: input.approvalId,
-                events: [nativeEvent('approval.resolved', { approvalId: input.approvalId, accepted: input.accepted })],
-            };
-            return result;
+            return { outcome: 'accepted', approvalId: input.approvalId, turnId: found?.turnId };
+        },
+        async readThread(input) {
+            const thread = threads.get(input.threadId);
+            if (!thread || thread.sessionId !== input.sessionId)
+                return undefined;
+            return projectNativeThread(input.threadId, {
+                id: input.threadId,
+                turns: [{ items: thread.items }],
+            });
         },
     };
 }

package/dist/workspace-runtime/codex/native-adapter.js

@@ -1,3 +1,6 @@
 export function nativeEvent(type, payload) {
     return { type, payload, occurredAt: new Date().toISOString() };
 }
+export function collectedEvent(kind, method, params) {
+    return { kind, method, params, occurredAt: new Date().toISOString() };
+}