@pasko70/pibo 1.16.6 → 2.0.0

package/dist/apps/chat/model-catalog.js

@@ -1,55 +1 @@
-import { createAgentSessionServices } from "@earendil-works/pi-coding-agent";
-import { registerMiniMaxProvider } from "../../providers/minimax.js";
-import { registerGlmProvider } from "../../providers/glm.js";
-import { registerOpenAiGpt56Models } from "../../providers/openai-gpt56.js";
-import { registerQwenTokenPlanProvider } from "../../providers/qwen-token-plan.js";
-export function buildModelCatalogFromRegistry(registry) {
-    const providers = new Map();
-    for (const model of registry.getAll()) {
-        const providerId = model.provider;
-        let provider = providers.get(providerId);
-        if (!provider) {
-            const authConfigured = registry.getProviderAuthStatus?.(providerId).configured ?? false;
-            provider = {
-                id: providerId,
-                label: registry.getProviderDisplayName?.(providerId) ?? providerId,
-                authConfigured,
-                models: [],
-            };
-            providers.set(providerId, provider);
-        }
-        provider.models.push({
-            provider: providerId,
-            id: model.id,
-            label: model.name || model.id,
-            authConfigured: provider.authConfigured,
-            supportsReasoning: model.reasoning || undefined,
-        });
-    }
-    return {
-        providers: [...providers.values()]
-            .sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id))
-            .map((provider) => ({
-            ...provider,
-            models: [...provider.models].sort((left, right) => left.label.localeCompare(right.label) || left.id.localeCompare(right.id)),
-        })),
-    };
-}
-export async function loadModelCatalogWithServices(createServices, cwd = process.cwd(), extensionHook) {
-    try {
-        const services = await createServices({ cwd });
-        extensionHook?.(services.modelRegistry);
-        return buildModelCatalogFromRegistry(services.modelRegistry);
-    }
-    catch {
-        return { providers: [] };
-    }
-}
-export async function loadModelCatalog(cwd = process.cwd()) {
-    return loadModelCatalogWithServices(createAgentSessionServices, cwd, (registry) => {
-        registerOpenAiGpt56Models(registry);
-        registerMiniMaxProvider(registry);
-        registerGlmProvider(registry);
-        registerQwenTokenPlanProvider(registry);
-    });
-}
+export { buildModelCatalogFromRegistry, loadModelCatalog, loadModelCatalogWithServices, } from "../../agent-runtimes/pi/model-catalog.js";

package/dist/apps/chat/provider-auth-actions.js

@@ -1,36 +1,184 @@
 import { randomUUID } from "node:crypto";
-import { completeLogin, getLoginStatus, removeLogin, setApiKey, startLogin } from "../../auth/login-actions.js";
+import { aggregateAgentRuntimeAuthState, redactAgentRuntimeAuthText } from "../../agent-runtime/auth.js";
+import { AgentRuntimeAuthError, AgentRuntimeCapabilityUnavailableError, AgentRuntimeContractError, AgentRuntimeUnavailableError, } from "../../agent-runtime/errors.js";
 import { PiboWebHttpError, responseJson } from "../../web/http.js";
 function isJsonObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function runtimeInstanceId(input) {
+    if (typeof input.runtimeInstanceId !== "string" || !input.runtimeInstanceId.trim()) {
+        throw new PiboWebHttpError("runtimeInstanceId is required for provider authentication", 400);
+    }
+    return input.runtimeInstanceId.trim();
+}
+function providerId(input, action) {
+    const provider = typeof input.providerId === "string" ? input.providerId : input.provider;
+    if (typeof provider !== "string" || !provider.trim()) {
+        throw new PiboWebHttpError(`${action} requires providerId`, 400);
+    }
+    return provider.trim();
+}
+function flowId(input, action) {
+    const value = typeof input.flowId === "string" && input.flowId.trim()
+        ? input.flowId
+        : typeof input.state === "string" && input.state.trim()
+            ? input.state
+            : undefined;
+    if (!value)
+        throw new PiboWebHttpError(`${action} requires flowId`, 400);
+    return value;
+}
+function safeRuntimeAuthError(error) {
+    if (error instanceof PiboWebHttpError)
+        throw error;
+    if (error instanceof AgentRuntimeAuthError
+        || error instanceof AgentRuntimeCapabilityUnavailableError
+        || error instanceof AgentRuntimeContractError
+        || error instanceof AgentRuntimeUnavailableError) {
+        throw new PiboWebHttpError(redactAgentRuntimeAuthText(error.message), error instanceof AgentRuntimeUnavailableError ? 404 : 409);
+    }
+    throw new PiboWebHttpError("Runtime provider authentication failed safely. Retry after checking the selected runtime.", 502);
+}
 export function isProviderAuthAction(action) {
-    return action === "login.status" || action === "login.start" || action === "login.complete" || action === "login.apikey" || action === "logout";
+    return action === "login.status"
+        || action === "login.start"
+        || action === "login.complete"
+        || action === "login.apikey"
+        || action === "login.cancel"
+        || action === "logout";
+}
+export function buildProviderAuthCatalog(inspections, defaultRuntimeInstanceId) {
+    return {
+        ...(defaultRuntimeInstanceId ? { defaultRuntimeInstanceId } : {}),
+        targets: inspections.map((runtime) => {
+            const supported = runtime.capabilities.auth.status;
+            const providers = runtime.auth ?? [];
+            const state = !supported
+                ? "unsupported"
+                : !runtime.enabled || !runtime.available
+                    ? "failed"
+                    : aggregateAgentRuntimeAuthState(providers, true);
+            return {
+                runtimeInstanceId: runtime.id,
+                adapterId: runtime.adapterId,
+                displayName: runtime.displayName,
+                enabled: runtime.enabled,
+                available: runtime.available,
+                isDefault: runtime.id === defaultRuntimeInstanceId,
+                credentialScope: runtime.capabilities.auth.credentialScope,
+                cancelSupported: runtime.capabilities.auth.cancel,
+                logoutSupported: runtime.capabilities.auth.logout,
+                state,
+                providers: providers.map((provider) => structuredClone(provider)),
+                diagnostics: runtime.diagnostics.map(({ severity, code, message }) => ({ severity, code, message })),
+            };
+        }),
+    };
+}
+export async function readProviderAuthCatalog(context, defaultRuntimeInstanceId) {
+    const configured = context.getCapabilityCatalog?.().agentRuntimes;
+    const inspections = configured
+        ? configured.map((runtime) => ({ ...runtime, available: runtime.enabled, diagnostics: [] }))
+        : context.inspectAgentRuntimeInstances
+            ? await context.inspectAgentRuntimeInstances()
+            : (() => { throw new PiboWebHttpError("Runtime authentication inspection is not available", 501); })();
+    const refreshed = await Promise.all(inspections.map(async (runtime) => {
+        if (!runtime.enabled || !runtime.capabilities.auth.status || !context.getAgentRuntimeAuthStatus)
+            return runtime;
+        try {
+            return { ...runtime, auth: [...await context.getAgentRuntimeAuthStatus(runtime.id)] };
+        }
+        catch {
+            return {
+                ...runtime,
+                available: false,
+                auth: undefined,
+                diagnostics: [
+                    ...runtime.diagnostics,
+                    {
+                        severity: "warning",
+                        code: "runtime_auth_status_failed",
+                        message: `Authentication status is unavailable for runtime instance "${runtime.id}".`,
+                    },
+                ],
+            };
+        }
+    }));
+    return buildProviderAuthCatalog(refreshed, defaultRuntimeInstanceId);
 }
-export async function executeProviderAuthAction(action, params) {
+export async function executeProviderAuthAction(context, action, params) {
     const input = isJsonObject(params) ? params : {};
-    const provider = typeof input.provider === "string" ? input.provider : undefined;
-    if (action === "login.status")
-        return { providers: getLoginStatus(provider) };
-    if (!provider)
-        throw new PiboWebHttpError(`${action} requires params.provider`, 400);
-    if (action === "login.start")
-        return await startLogin(provider);
-    if (action === "login.complete") {
-        if (input.code !== undefined && typeof input.code !== "string")
-            throw new PiboWebHttpError("login.complete params.code must be a string when provided", 400);
-        if (typeof input.state !== "string" || input.state.length === 0)
-            throw new PiboWebHttpError("login.complete requires params.state", 400);
-        return await completeLogin(provider, input.code, input.state);
+    try {
+        const selectedRuntime = runtimeInstanceId(input);
+        if (action === "login.status") {
+            if (!context.getAgentRuntimeAuthStatus)
+                throw new PiboWebHttpError("Runtime authentication status is not available", 501);
+            const selectedProvider = typeof input.providerId === "string"
+                ? input.providerId
+                : typeof input.provider === "string"
+                    ? input.provider
+                    : undefined;
+            const providers = await context.getAgentRuntimeAuthStatus(selectedRuntime);
+            return {
+                runtimeInstanceId: selectedRuntime,
+                providers: selectedProvider ? providers.filter((provider) => provider.id === selectedProvider) : providers,
+            };
+        }
+        const selectedProvider = providerId(input, action);
+        if (action === "login.start") {
+            if (!context.startAgentRuntimeAuth)
+                throw new PiboWebHttpError("Runtime authentication login is not available", 501);
+            let method = input.method;
+            if (method === undefined) {
+                if (!context.getAgentRuntimeAuthStatus)
+                    throw new PiboWebHttpError("Runtime authentication status is not available", 501);
+                const status = (await context.getAgentRuntimeAuthStatus(selectedRuntime)).find((provider) => provider.id === selectedProvider);
+                method = status?.methods.find((candidate) => candidate.id !== "api_key")?.id;
+            }
+            if (method !== "device_code" && method !== "browser_oauth") {
+                throw new PiboWebHttpError("login.start requires a supported interactive method", 400);
+            }
+            return await context.startAgentRuntimeAuth(selectedRuntime, { providerId: selectedProvider, method });
+        }
+        if (action === "login.apikey") {
+            if (!context.startAgentRuntimeAuth)
+                throw new PiboWebHttpError("Runtime API-key authentication is not available", 501);
+            if (typeof input.apiKey !== "string" || input.apiKey.length === 0) {
+                throw new PiboWebHttpError("login.apikey requires apiKey", 400);
+            }
+            const start = { providerId: selectedProvider, method: "api_key", apiKey: input.apiKey };
+            return await context.startAgentRuntimeAuth(selectedRuntime, start);
+        }
+        if (action === "login.complete") {
+            if (!context.completeAgentRuntimeAuth)
+                throw new PiboWebHttpError("Runtime authentication completion is not available", 501);
+            if (input.code !== undefined && typeof input.code !== "string") {
+                throw new PiboWebHttpError("login.complete code must be a string when provided", 400);
+            }
+            return await context.completeAgentRuntimeAuth(selectedRuntime, {
+                providerId: selectedProvider,
+                flowId: flowId(input, action),
+                ...(typeof input.code === "string" ? { code: input.code } : {}),
+            });
+        }
+        if (action === "login.cancel") {
+            if (!context.cancelAgentRuntimeAuth)
+                throw new PiboWebHttpError("Runtime authentication cancellation is not available", 501);
+            return await context.cancelAgentRuntimeAuth(selectedRuntime, {
+                providerId: selectedProvider,
+                flowId: flowId(input, action),
+            });
+        }
+        if (action === "logout") {
+            if (!context.logoutAgentRuntimeAuth)
+                throw new PiboWebHttpError("Runtime authentication logout is not available", 501);
+            return await context.logoutAgentRuntimeAuth(selectedRuntime, { providerId: selectedProvider });
+        }
+        throw new PiboWebHttpError(`Unsupported provider auth action ${action}`, 400);
     }
-    if (action === "login.apikey") {
-        if (typeof input.apiKey !== "string" || input.apiKey.length === 0)
-            throw new PiboWebHttpError("login.apikey requires params.apiKey", 400);
-        return setApiKey(provider, input.apiKey);
+    catch (error) {
+        safeRuntimeAuthError(error);
     }
-    if (action === "logout")
-        return removeLogin(provider);
-    throw new PiboWebHttpError(`Unsupported provider auth action ${action}`, 400);
 }
 export function providerAuthActionResponse(input) {
     return responseJson({

package/dist/apps/chat/stream.js

@@ -102,6 +102,18 @@ export function chatStreamFramesFromOutputEvent(event, state, options = {}) {
         case "execution_result":
             frames.push({ type: "EXECUTION_RESULT", runId: eventId, eventId: event.eventId, action: event.action, result: event.result });
             break;
+        case "approval_requested":
+            frames.push({ type: "RUNTIME_APPROVAL_REQUESTED", runId: eventId, request: event.request });
+            break;
+        case "approval_resolved":
+            frames.push({ type: "RUNTIME_APPROVAL_RESOLVED", runId: eventId, requestId: event.requestId, resolution: event.resolution });
+            break;
+        case "user_input_requested":
+            frames.push({ type: "RUNTIME_USER_INPUT_REQUESTED", runId: eventId, request: event.request });
+            break;
+        case "user_input_resolved":
+            frames.push({ type: "RUNTIME_USER_INPUT_RESOLVED", runId: eventId, requestId: event.requestId, resolution: event.resolution });
+            break;
         case "session_error":
             frames.push({ type: "RUN_ERROR", runId: eventId, message: event.error, errorDetails: event.errorDetails });
             break;

package/dist/apps/chat/trace-v2.js

@@ -27,6 +27,7 @@ export function traceTimelinePageFromView(input) {
     let page = {
         piboSessionId: input.trace.piboSessionId,
         piSessionId: input.trace.piSessionId,
+        runtimeBinding: input.trace.runtimeBinding,
         title: input.trace.title,
         version: input.trace.version,
         latestStreamId: input.trace.latestStreamId,