@timurproko/a1 0.1.8-dev.472 → 0.1.8-dev.508

package/dist/integrations/pi/engine/prompt-suggestions.d.ts

@@ -0,0 +1,30 @@
+import type { AgentSession, AgentSessionRuntime } from "../startup-public.js";
+import { type OwnedUiModelInfo, type OwnedUiPromptSuggestionGeneratorPort, type OwnedUiPromptSuggestionReasoning, type OwnedUiPromptSuggestionRequest, type OwnedUiPromptSuggestionResult } from "../../../contracts/owned-ui/index.js";
+/** The run position a suggestion request must still match to be answered. */
+export interface PiPromptSuggestionIdentity {
+    readonly sessionId: string;
+    readonly sessionGeneration: number;
+    readonly runSequence: number;
+    readonly responseSequence: number;
+}
+export interface PiPromptSuggestionPorts {
+    session(): AgentSession | undefined;
+    runtime(): AgentSessionRuntime | undefined;
+    activeModel(): OwnedUiModelInfo | null;
+    /** The adapter's current position; a request for an earlier position is answered "unavailable". */
+    identity(): PiPromptSuggestionIdentity;
+    /** True while the adapter cannot serve: disposed, overloaded, or admission stopped. */
+    unavailable(): boolean;
+}
+/**
+ * Contextual prompt suggestions generated against the bound session's own conversation prefix
+ * through pinned Pi's model runtime, so the provider serves the suggestion from the run's prompt
+ * cache. The adapter supplies the session, runtime, model, and run position through ports and
+ * remains the port the owned UI calls.
+ */
+export declare class PiPromptSuggestions implements OwnedUiPromptSuggestionGeneratorPort {
+    #private;
+    constructor(ports: PiPromptSuggestionPorts);
+    reasoningPolicy(): OwnedUiPromptSuggestionReasoning;
+    generate(request: OwnedUiPromptSuggestionRequest): Promise<OwnedUiPromptSuggestionResult>;
+}

package/dist/integrations/pi/engine/prompt-suggestions.js

@@ -0,0 +1,102 @@
+import { isRecord, stringValue } from "./message-values.js";
+import { CONTEXTUAL_PROMPT_SUGGESTION_INSTRUCTION, assertOwnedUiPromptSuggestionRequest, assertOwnedUiPromptSuggestionResult, normalizePromptSuggestionCandidate, } from "../../../contracts/owned-ui/index.js";
+/**
+ * Contextual prompt suggestions generated against the bound session's own conversation prefix
+ * through pinned Pi's model runtime, so the provider serves the suggestion from the run's prompt
+ * cache. The adapter supplies the session, runtime, model, and run position through ports and
+ * remains the port the owned UI calls.
+ */
+export class PiPromptSuggestions {
+    #ports;
+    constructor(ports) {
+        this.#ports = ports;
+    }
+    reasoningPolicy() {
+        const session = this.#ports.session();
+        if (!session?.model)
+            return "unavailable";
+        if (!session.model.reasoning)
+            return "ordinary";
+        // Performance: the run's own level keeps the provider's thinking parameters, and the cached prefix, identical.
+        return readSuggestionReasoning(session.thinkingLevel);
+    }
+    async generate(request) {
+        assertOwnedUiPromptSuggestionRequest(request);
+        const identity = request.identity;
+        const session = this.#ports.session();
+        const runtime = this.#ports.runtime();
+        const activeModel = this.#ports.activeModel();
+        const current = this.#ports.identity();
+        if (this.#ports.unavailable() || session === undefined || runtime === undefined || request.signal.aborted
+            || identity.sessionId !== current.sessionId
+            || identity.sessionGeneration !== current.sessionGeneration
+            || identity.runSequence !== current.runSequence
+            || identity.responseSequence !== current.responseSequence
+            || activeModel === null
+            || identity.model.providerId !== activeModel.providerId
+            || identity.model.modelId !== activeModel.modelId) {
+            return { identity, outcome: request.signal.aborted ? "cancelled" : "unavailable", text: null };
+        }
+        const model = session.model;
+        const agent = session.agent;
+        const agentState = agent.state;
+        const policy = this.reasoningPolicy();
+        if (model === undefined || policy === "unavailable" || typeof runtime.services.modelRuntime.completeSimple !== "function") {
+            return { identity, outcome: "unavailable", text: null };
+        }
+        // Performance: mirror the primary loop's request shape so the provider serves the conversation prefix
+        // from the run's prompt cache. `onResponse` stays out: extensions must not see a suggestion as a response.
+        const reasoning = policy === "ordinary" || policy === "off" ? undefined : policy;
+        let response;
+        try {
+            const transformed = typeof agent.transformContext === "function"
+                ? await agent.transformContext(agentState.messages, request.signal)
+                : agentState.messages;
+            const messages = typeof agent.convertToLlm === "function"
+                ? await agent.convertToLlm(transformed)
+                : transformed.filter(message => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
+            response = await runtime.services.modelRuntime.completeSimple(model, {
+                systemPrompt: agentState.systemPrompt,
+                messages: [
+                    ...messages,
+                    { role: "user", content: CONTEXTUAL_PROMPT_SUGGESTION_INSTRUCTION, timestamp: Date.now() },
+                ],
+                tools: agentState.tools,
+            }, {
+                signal: request.signal,
+                ...(reasoning === undefined ? {} : { reasoning }),
+                ...(agent.sessionId === undefined ? {} : { sessionId: agent.sessionId }),
+                ...(agent.thinkingBudgets === undefined ? {} : { thinkingBudgets: agent.thinkingBudgets }),
+                ...(agent.transport === undefined ? {} : { transport: agent.transport }),
+                ...(agent.onPayload === undefined ? {} : { onPayload: agent.onPayload }),
+            });
+        }
+        catch {
+            return { identity, outcome: request.signal.aborted ? "cancelled" : "provider-failure", text: null };
+        }
+        if (request.signal.aborted || (isRecord(response) && response.stopReason === "aborted")) {
+            return { identity, outcome: "cancelled", text: null };
+        }
+        if (!isRecord(response) || stringValue(response.errorMessage) !== undefined || response.stopReason === "error") {
+            return { identity, outcome: "provider-failure", text: null };
+        }
+        const content = Array.isArray(response.content) ? response.content : [];
+        if (response.stopReason === "length" || content.some(block => isRecord(block) && block.type === "toolCall")) {
+            return { identity, outcome: "rejected", text: null };
+        }
+        // Security: validate all text, not just the first block of a multi-part response.
+        const rawText = content.filter(block => isRecord(block) && block.type === "text")
+            .map(block => stringValue(block.text) ?? "").join("\n");
+        const text = normalizePromptSuggestionCandidate(rawText);
+        const result = text === null
+            ? { identity, outcome: rawText.trim() ? "rejected" : "empty", text: null }
+            : { identity, outcome: "candidate", text };
+        assertOwnedUiPromptSuggestionResult(result);
+        return result;
+    }
+}
+function readSuggestionReasoning(value) {
+    return value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max"
+        ? value
+        : "off";
+}

package/dist/integrations/pi/engine/provider-authentication.d.ts

@@ -0,0 +1,34 @@
+import { type AgentSession, type AgentSessionRuntime } from "../startup-public.js";
+import type { PiWorkflowContexts } from "./workflow-contexts.js";
+import type { OwnedUiModelInfo } from "../../../contracts/owned-ui/index.js";
+import type { PiWorkflowInteractionHost, PiWorkflowRequest, PiWorkflowResult } from "./workflows.js";
+type PiSessionApi = AgentSession;
+type PiRuntimeApi = AgentSessionRuntime;
+export interface PiProviderAuthenticationPorts {
+    runtime(): PiRuntimeApi | undefined;
+    requireSession(): PiSessionApi;
+    disposed(): boolean;
+    sessionGeneration(): number;
+    interaction(): PiWorkflowInteractionHost;
+    setActiveModel(model: OwnedUiModelInfo): void;
+    reconcileActiveModelAvailability(): void;
+    emitView(): void;
+}
+/**
+ * Pinned Pi's provider login and logout: resolving a provider reference to an authentication
+ * method, driving the model runtime's login through the owned interaction host, selecting the
+ * provider's pinned default model when the session had none, and the deferred catalog refresh
+ * whose notices follow the saved-credential status. Wording follows pinned Pi exactly.
+ */
+export declare class PiProviderAuthentication {
+    #private;
+    constructor(options: {
+        readonly agentDir: string;
+        readonly contexts: PiWorkflowContexts;
+    }, ports: PiProviderAuthenticationPorts);
+    /** Run pinned Pi's `/login` for a provider reference or an explicit `type:provider` selection. */
+    login(request: PiWorkflowRequest, session: PiSessionApi, runtime: PiRuntimeApi, argument: string, selection: string | undefined): Promise<PiWorkflowResult>;
+    /** Run pinned Pi's `/logout` for a `type:provider` selection. */
+    logout(request: PiWorkflowRequest, runtime: PiRuntimeApi, selection: string): Promise<PiWorkflowResult>;
+}
+export {};

package/dist/integrations/pi/engine/provider-authentication.js

@@ -0,0 +1,209 @@
+import { join } from "node:path";
+import { isRecord, requireCapability, stringProperty } from "./message-values.js";
+import { CredentialSynchronizationError } from "../startup-public.js";
+import { AUTH_REFRESH_TIMEOUT_MS, isUnknownModel, PINNED_DEFAULT_MODEL_BY_PROVIDER, workflowLoginNotification, workflowResult } from "./workflow-support.js";
+/**
+ * Pinned Pi's provider login and logout: resolving a provider reference to an authentication
+ * method, driving the model runtime's login through the owned interaction host, selecting the
+ * provider's pinned default model when the session had none, and the deferred catalog refresh
+ * whose notices follow the saved-credential status. Wording follows pinned Pi exactly.
+ */
+export class PiProviderAuthentication {
+    #agentDir;
+    #contexts;
+    #ports;
+    constructor(options, ports) {
+        this.#agentDir = options.agentDir;
+        this.#contexts = options.contexts;
+        this.#ports = ports;
+    }
+    /** Run pinned Pi's `/login` for a provider reference or an explicit `type:provider` selection. */
+    async login(request, session, runtime, argument, selection) {
+        if (!selection && !argument)
+            return workflowResult(request.command, "failed", "Login requires the owned authentication controller");
+        const modelRuntime = runtime.services.modelRuntime;
+        let loginSelection = selection ?? argument;
+        if (!selection && argument && !argument.includes(":")) {
+            const normalized = argument.toLowerCase();
+            const providers = modelRuntime.getProviders?.();
+            const providerMatches = Array.isArray(providers) ? providers.filter(isRecord).filter(candidate => stringProperty(candidate, "id")?.toLowerCase() === normalized
+                || stringProperty(candidate, "name")?.toLowerCase() === normalized) : [];
+            const providerReference = providerMatches.length === 1 ? stringProperty(providerMatches[0], "id") ?? argument : argument;
+            const matching = this.#contexts.loginOptions().filter(option => option.id.endsWith(`:${providerReference}`));
+            if (matching.length > 1) {
+                const provider = modelRuntime.getProvider?.(providerReference);
+                const providerName = stringProperty(provider, "name") ?? providerReference;
+                return workflowResult(request.command, "failed", `Authentication method for ${providerName} requires the owned authentication controller`);
+            }
+            if (matching[0])
+                loginSelection = matching[0].id;
+        }
+        const [authTypeValue = "oauth", providerId = loginSelection] = loginSelection.includes(":")
+            ? loginSelection.split(":", 2)
+            : ["oauth", loginSelection];
+        const authType = authTypeValue === "api_key" ? "api_key" : "oauth";
+        const provider = modelRuntime.getProvider?.(providerId);
+        const providerName = stringProperty(provider, "name") ?? providerId;
+        const previousModel = session.model;
+        this.#ports.interaction().startLogin?.({ providerId, providerName, authType });
+        try {
+            await requireCapability(modelRuntime.login, "login").call(modelRuntime, providerId, authType, {
+                signal: AbortSignal.timeout(120_000),
+                prompt: async (prompt) => {
+                    const promptType = stringProperty(prompt, "type");
+                    const options = isRecord(prompt) && Array.isArray(prompt.options)
+                        ? prompt.options.filter(isRecord).flatMap(option => {
+                            const id = stringProperty(option, "id");
+                            const label = stringProperty(option, "label");
+                            return id && label ? [{ id, label }] : [];
+                        })
+                        : [];
+                    const response = await this.#ports.interaction().prompt({
+                        type: promptType === "select"
+                            ? "select"
+                            : promptType === "manual_code"
+                                ? "manual-code"
+                                : authType === "api_key"
+                                    ? "secret"
+                                    : "text",
+                        message: stringProperty(prompt, "message") ?? `Authenticate ${providerName}`,
+                        ...(stringProperty(prompt, "placeholder") === undefined ? {} : { placeholder: stringProperty(prompt, "placeholder") }),
+                        ...(options.length === 0 ? {} : { options }),
+                    });
+                    if (response === null)
+                        throw new Error("Login cancelled");
+                    return response;
+                },
+                notify: (event) => {
+                    const notification = workflowLoginNotification(event);
+                    if (notification)
+                        this.#ports.interaction().notify(notification);
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "Login cancelled") {
+                return workflowResult(request.command, "cancelled", "Login cancelled", undefined, "silent");
+            }
+            const detail = error instanceof Error ? error.message : String(error);
+            const actionLabel = authType === "api_key" ? `Saved API key for ${providerName}` : `Logged in to ${providerName}`;
+            const message = error instanceof CredentialSynchronizationError
+                ? `${actionLabel}, but local model state could not be synchronized: ${detail}`
+                : authType === "api_key"
+                    ? `Failed to save API key for ${providerName}: ${detail}`
+                    : `Failed to login to ${providerName}: ${detail}`;
+            return workflowResult(request.command, "failed", message);
+        }
+        finally {
+            this.#ports.interaction().finishLogin?.();
+        }
+        return await this.#completeProviderAuthentication(providerId, providerName, authType, previousModel);
+    }
+    /** Run pinned Pi's `/logout` for a `type:provider` selection. */
+    async logout(request, runtime, selection) {
+        const [credentialType = "oauth", providerId = selection] = selection.includes(":") ? selection.split(":", 2) : ["oauth", selection];
+        const modelRuntime = runtime.services.modelRuntime;
+        const provider = modelRuntime.getProvider?.(providerId);
+        const providerName = stringProperty(provider, "name") ?? providerId;
+        try {
+            await requireCapability(modelRuntime.logout, "logout").call(modelRuntime, providerId, { signal: AbortSignal.timeout(15_000) });
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            const message = error instanceof CredentialSynchronizationError
+                ? `Credentials removed for ${providerName}, but local model state could not be synchronized: ${detail}`
+                : `Logout failed: ${detail}`;
+            return workflowResult(request.command, "failed", message);
+        }
+        this.#ports.reconcileActiveModelAvailability();
+        this.#ports.emitView();
+        return workflowResult(request.command, "completed", credentialType === "api_key"
+            ? `Removed stored API key for ${providerName}. Environment variables and models.json config are unchanged.`
+            : `Logged out of ${providerName}`);
+    }
+    async #completeProviderAuthentication(providerId, providerName, authType, previousModel) {
+        const session = this.#ports.requireSession();
+        const modelRuntime = this.#ports.runtime()?.services.modelRuntime;
+        if (!modelRuntime)
+            throw new Error("engine runtime is unavailable");
+        const actionLabel = authType === "oauth" ? `Logged in to ${providerName}` : `Saved API key for ${providerName}`;
+        let selectedModelId;
+        let selectionError;
+        if (isUnknownModel(previousModel)) {
+            const available = modelRuntime.getAvailableSnapshot?.() ?? [];
+            const providerModels = available.filter(model => stringProperty(model, "provider") === providerId);
+            const defaultModelId = PINNED_DEFAULT_MODEL_BY_PROVIDER[providerId];
+            if (defaultModelId === undefined) {
+                selectionError = `${actionLabel}, but no default model is configured for provider "${providerId}". Use /model to select a model.`;
+            }
+            else if (providerModels.length === 0) {
+                selectionError = `${actionLabel}, but no models are available for that provider. Use /model to select a model.`;
+            }
+            else {
+                const selectedModel = providerModels.find(model => stringProperty(model, "id") === defaultModelId);
+                if (selectedModel === undefined) {
+                    selectionError = `${actionLabel}, but its default model "${defaultModelId}" is not available. Use /model to select a model.`;
+                }
+                else {
+                    try {
+                        await session.setModel(selectedModel);
+                        selectedModelId = stringProperty(selectedModel, "id") ?? defaultModelId;
+                        this.#ports.setActiveModel({
+                            providerId,
+                            modelId: selectedModelId,
+                            displayName: stringProperty(selectedModel, "name") ?? selectedModelId,
+                        });
+                    }
+                    catch (error) {
+                        selectionError = `${actionLabel}, but selecting its default model failed: ${error instanceof Error ? error.message : String(error)}. Use /model to select a model.`;
+                    }
+                }
+            }
+        }
+        this.#ports.reconcileActiveModelAvailability();
+        this.#ports.emitView();
+        const status = `${actionLabel}.${selectedModelId ? ` Selected ${selectedModelId}.` : ""} Credentials saved to ${join(this.#agentDir, "auth.json")}`;
+        const messages = [
+            { kind: "status", message: status },
+            ...(selectionError === undefined ? [] : [{ kind: "error", message: selectionError }]),
+        ];
+        this.#scheduleAuthenticatedProviderRefresh(providerId, actionLabel);
+        return workflowResult("login", "completed", status, undefined, "status", messages);
+    }
+    #scheduleAuthenticatedProviderRefresh(providerId, actionLabel) {
+        const runtime = this.#ports.runtime();
+        const refresh = runtime?.services.modelRuntime.refresh;
+        if (!runtime || typeof refresh !== "function")
+            return;
+        const generation = this.#ports.sessionGeneration();
+        const publish = this.#ports.interaction().publish;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), AUTH_REFRESH_TIMEOUT_MS);
+        // Compatibility: post-authentication refresh starts on the next turn so its notices follow the saved-credential status.
+        void new Promise(resolve => setTimeout(resolve, 0))
+            .then(() => refresh.call(runtime.services.modelRuntime, { providers: [providerId], signal: controller.signal }))
+            .then(result => {
+            if (this.#ports.disposed() || this.#ports.sessionGeneration() !== generation)
+                return;
+            if (isRecord(result) && result.aborted === true) {
+                publish?.({ kind: "warning", message: `${actionLabel}, but its model catalog refresh timed out; using cached models.` });
+            }
+            else if (isRecord(result) && result.errors instanceof Map && result.errors.size > 0) {
+                publish?.({ kind: "warning", message: `${actionLabel}, but its model catalog could not be refreshed; using cached models.` });
+            }
+            this.#ports.reconcileActiveModelAvailability();
+            this.#ports.emitView();
+        })
+            .catch(error => {
+            if (this.#ports.disposed() || this.#ports.sessionGeneration() !== generation)
+                return;
+            publish?.({
+                kind: "warning",
+                message: controller.signal.aborted
+                    ? `${actionLabel}, but its model catalog refresh timed out; using cached models.`
+                    : `${actionLabel}, but its model catalog could not be refreshed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        })
+            .finally(() => clearTimeout(timeout));
+    }
+}

package/dist/integrations/pi/engine/resource-catalog.d.ts

@@ -0,0 +1,49 @@
+import type { AgentSession, AgentSessionRuntime } from "../startup-public.js";
+import type { PiWorkflowContexts } from "./workflow-contexts.js";
+import { type PiWorkflowAutocompleteCommand } from "./workflows.js";
+export interface OwnedPiResourceSummary {
+    readonly kind: "skill" | "prompt-template" | "agent-context" | "system-prompt" | "theme";
+    readonly id: string;
+    readonly label: string;
+    readonly sourcePath: string | null;
+    readonly diagnostic: string | null;
+}
+export interface OwnedPiExtensionSourceSummary {
+    readonly source: string;
+    readonly scope: "user" | "project" | "temporary";
+    readonly origin: "package" | "top-level";
+    readonly baseDir: string | null;
+}
+export interface OwnedPiExtensionResourceSummary {
+    readonly kind: "extension";
+    readonly id: string;
+    readonly sourcePath: string | null;
+    readonly resolvedPath: string | null;
+    readonly sourceInfo: OwnedPiExtensionSourceSummary | null;
+    readonly loaded: boolean;
+    readonly hidden: boolean;
+    readonly diagnostic: string | null;
+}
+export interface PiResourceCatalogPorts {
+    session(): AgentSession | undefined;
+    runtime(): AgentSessionRuntime | undefined;
+}
+/**
+ * The resources pinned Pi's loader discovered for the current runtime (skills, prompt templates,
+ * agent context files, system prompts, themes, extensions) and the slash-command autocomplete
+ * entries derived from them, shaped for the owned shell with the loader's diagnostics carried
+ * along instead of thrown. Reads only; the runtime and session are reached through ports.
+ */
+export declare class PiResourceCatalog {
+    #private;
+    constructor(options: {
+        readonly contexts: PiWorkflowContexts;
+    }, ports: PiResourceCatalogPorts);
+    nonVisualResources(): readonly OwnedPiResourceSummary[];
+    extensionResources(): readonly OwnedPiExtensionResourceSummary[];
+    workflowAutocompleteCommands(): readonly PiWorkflowAutocompleteCommand[];
+}
+export declare function collectionResult(value: unknown, key: string): {
+    values: readonly unknown[];
+    diagnostics: readonly string[];
+};