@tea-agent/loop-agent 0.43.0-next.9 → 0.43.0

package/dist/worker/console/chat/pi-runtime/sdk-bindings.js

@@ -0,0 +1,153 @@
+/**
+ * Concrete Pi SDK adapter for Console Chat. Lazy-loads the ESM SDK and
+ * implements session-file safety (wx/0600, missing-file fail-closed).
+ */
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+export async function safeGetAgentDir(bindings) {
+    try {
+        return await bindings.getAgentDir();
+    }
+    catch {
+        // Fall back to a Console-app-data scoped agent dir so we never accidentally
+        // touch the user's real ~/.pi/agent config if getAgentDir throws.
+        return path.join(process.cwd(), ".harness", "console", "pi-agent-dir");
+    }
+}
+/**
+ * Cached SDK module loader. The pi-coding-agent package is ESM-only, so we
+ * must use dynamic import() (not require). Cached to avoid repeated imports.
+ */
+let cachedSdk;
+async function loadSdk() {
+    if (!cachedSdk) {
+        cachedSdk = import("@earendil-works/pi-coding-agent");
+    }
+    return cachedSdk;
+}
+/**
+ * Default production bindings backed by the real Pi SDK (services mode).
+ * Dynamically imported so the worker bundle does not hard-fail if the SDK is
+ * absent at module load (discovered lazily by pi-readiness instead).
+ */
+export function createDefaultPiSdkBindings() {
+    return {
+        getAgentDir: async () => {
+            const sdk = (await loadSdk());
+            return sdk.getAgentDir();
+        },
+        createServices: async (opts) => {
+            const sdk = (await loadSdk());
+            // createAgentSessionServices returns the full AgentSessionServices object
+            // directly (cwd/agentDir/modelRuntime/settingsManager/resourceLoader).
+            // Wrap it so our type contract is satisfied.
+            const result = await sdk.createAgentSessionServices({
+                cwd: opts.cwd,
+                agentDir: opts.agentDir,
+                resourceLoaderOptions: opts.resourceLoaderOptions,
+            });
+            return { services: result };
+        },
+        createSessionFromServices: async (opts) => {
+            const sdk = (await loadSdk());
+            return sdk.createAgentSessionFromServices({
+                services: opts.services,
+                sessionManager: opts.sessionManager,
+                ...(opts.tools ? { tools: opts.tools } : {}),
+                ...(opts.noTools ? { noTools: opts.noTools } : {}),
+                ...(opts.excludeTools ? { excludeTools: opts.excludeTools } : {}),
+                ...(opts.customTools ? { customTools: opts.customTools } : {}),
+                ...(opts.model ? { model: opts.model } : {}),
+            });
+        },
+        createSessionManager: async (opts) => {
+            const sdk = (await loadSdk());
+            return sdk.SessionManager.create(opts.cwd, opts.sessionDir, {
+                id: opts.sessionId,
+            });
+        },
+        materializeSessionShell: async (opts) => {
+            const sdk = (await loadSdk());
+            const manager = opts.sessionManager;
+            if (typeof manager.setSessionFile !== "function") {
+                throw new Error("Pi SessionManager cannot materialize a session file");
+            }
+            let created = false;
+            try {
+                await mkdir(path.dirname(opts.sessionFile), { recursive: true });
+                // Match Pi's documented session header. Rebinding through the public
+                // SessionManager API marks it flushed, so Pi appends the first user
+                // entry instead of trying to create the already-present file later.
+                await writeFile(opts.sessionFile, `${JSON.stringify({
+                    type: "session",
+                    version: typeof sdk.CURRENT_SESSION_VERSION === "number"
+                        ? sdk.CURRENT_SESSION_VERSION
+                        : 3,
+                    id: opts.sessionId,
+                    timestamp: new Date().toISOString(),
+                    cwd: opts.cwd,
+                })}\n`, { encoding: "utf8", flag: "wx", mode: 0o600 });
+                created = true;
+                manager.setSessionFile(opts.sessionFile);
+            }
+            catch (error) {
+                if (created)
+                    await rm(opts.sessionFile, { force: true }).catch(() => undefined);
+                throw error;
+            }
+        },
+        createInMemorySessionManager: async (opts) => {
+            const sdk = (await loadSdk());
+            return sdk.SessionManager.inMemory(opts.cwd);
+        },
+        forkSessionManager: async (opts) => {
+            const sdk = (await loadSdk());
+            return sdk.SessionManager.forkFrom(opts.sourcePath, opts.targetCwd, opts.targetSessionDir, { id: opts.targetSessionId });
+        },
+        openSessionManager: async (opts) => {
+            const sdk = (await loadSdk());
+            try {
+                // Pi SessionManager.open(missingPath) does NOT throw — it creates a
+                // fresh in-memory session with a random UUID. That would reopen the
+                // wrong conversation under the durable Console sessionId. Fail closed
+                // before open when the persisted file is absent.
+                await access(opts.sessionFile);
+            }
+            catch (error) {
+                const code = error && typeof error === "object" && "code" in error
+                    ? String(error.code ?? "")
+                    : "";
+                if (code === "ENOENT") {
+                    throw Object.assign(new Error(`SESSION_FILE_MISSING: ${opts.sessionFile}`), { code: "SESSION_FILE_MISSING", cause: error });
+                }
+                // File exists but is unreadable (permissions / I/O) — caller maps
+                // undefined to 503 rather than silently creating a fresh session.
+                return undefined;
+            }
+            return sdk.SessionManager.open(opts.sessionFile);
+        },
+        resolveModel: (opts) => {
+            const rt = opts.modelRuntime;
+            if (typeof rt?.getModel !== "function")
+                return undefined;
+            try {
+                return rt.getModel(opts.provider, opts.modelId);
+            }
+            catch {
+                return undefined;
+            }
+        },
+        listAvailableModels: (opts) => {
+            const rt = opts.modelRuntime;
+            const available = rt?.snapshot?.available ?? [];
+            const configured = rt?.snapshot?.configuredProviders;
+            const isConfigured = (provider) => configured instanceof Set ? configured.has(provider) : false;
+            return available.map((m) => ({
+                id: m.id,
+                name: m.name,
+                provider: m.provider,
+                hasCredentials: isConfigured(m.provider),
+            }));
+        },
+    };
+}

package/dist/worker/console/chat/pi-runtime/sdk-session.js

@@ -0,0 +1,5 @@
+/**
+ * Pi SDK session contracts used by Console Chat. Kept below pi-runtime.ts so
+ * adapters and subagents can import types without a runtime cycle.
+ */
+export {};