@timurproko/a1 0.2.6-dev.736 → 0.2.7-dev.1221

package/dist/integrations/pi/engine/command-dispatch.d.ts

@@ -1,5 +1,7 @@
 import { type OwnedUiCommand, type OwnedUiCommandResult, type OwnedUiDiagnostics } from "../../../contracts/owned-ui/index.js";
 import type { PiEmittedEvent } from "./event-delivery.js";
+import type { PiEngineRuntime } from "./session-runtime.js";
+import type { EngineViewState } from "./view-state.js";
 export type AdapterCommandResult = OwnedUiCommandResult;
 export interface PiCommandDispatchPorts {
     sessionId(): string;
@@ -36,3 +38,14 @@ export declare class PiCommandDispatch {
     reset(): void;
     execute(command: OwnedUiCommand): Promise<AdapterCommandResult>;
 }
+/** What carrying out a command reaches: the running engine, the view state it updates, and disposal. */
+export interface EngineCommandContext {
+    readonly engine: Pick<PiEngineRuntime, "runtime" | "session" | "generation" | "sessionCommands">;
+    readonly state: Pick<EngineViewState, "activeModel" | "thinkingLevel" | "setTerminal" | "terminal">;
+    /** False while delivery is overloaded or admission is stopped; a late model change then stays unpublished. */
+    admissionOpen(): boolean;
+    emit(value: PiEmittedEvent): void;
+    dispose(): Promise<void>;
+}
+/** Carries out one admitted command against the running engine; throws when no session runs or the command fails. */
+export declare function performEngineCommand(command: OwnedUiCommand, context: EngineCommandContext): Promise<void>;

package/dist/integrations/pi/engine/command-dispatch.js

@@ -123,3 +123,60 @@ export class PiCommandDispatch {
         return { outcome, diagnostic };
     }
 }
+// Invariant: prompt input and session controls run through the engine's own session commands, which own queuing and images.
+async function runSessionCommand(request, context) {
+    const result = await context.engine.sessionCommands?.execute(request);
+    if (!result || result.outcome === "rejected" || result.outcome === "failed") {
+        throw new Error(request.type === "retry" ? "no previous prompt is available to retry" : `Pi session command failed: ${request.type}`);
+    }
+}
+function runPromptCommand(command, context) {
+    return runSessionCommand({
+        type: command.type,
+        text: command.text,
+        ...(command.images === undefined ? {} : { images: [...command.images] }),
+    }, context);
+}
+const ownedUiStateCommand = () => {
+    throw new Error("owned UI state commands belong to the owned UI layer, not the Pi engine adapter");
+};
+// Invariant: one handler per command type; the table is exhaustive, so a new command type cannot be silently ignored.
+const ENGINE_COMMANDS = {
+    "prompt": (command, context) => runPromptCommand(command, context),
+    "steer": (command, context) => runPromptCommand(command, context),
+    "follow-up": (command, context) => runPromptCommand(command, context),
+    "abort": (_command, context) => runSessionCommand({ type: "abort" }, context),
+    "retry": (_command, context) => runSessionCommand({ type: "retry" }, context),
+    "compact": (_command, context) => runSessionCommand({ type: "compact" }, context),
+    "set-model": async (command, context, { runtime, session, generation }) => {
+        const model = runtime.services.modelRuntime.getModel(command.model.providerId, command.model.modelId);
+        if (!model)
+            throw new Error(`model is unavailable: ${command.model.providerId}/${command.model.modelId}`);
+        await session.setModel(model);
+        if (generation === context.engine.generation && context.admissionOpen())
+            context.state.activeModel = { ...command.model };
+    },
+    "set-thinking-level": (command, context, { session }) => {
+        session.setThinkingLevel(command.thinkingLevel);
+        context.state.thinkingLevel = command.thinkingLevel;
+    },
+    "new-session": async (_command, _context, { runtime }) => { await runtime.newSession(); },
+    "resume-session": async (command, _context, { runtime }) => { await runtime.switchSession(command.sessionPath); },
+    "resize-surface": (command, context) => {
+        context.state.setTerminal(command.surface);
+        context.emit({ type: "terminal-surface", surface: context.state.terminal });
+    },
+    "shutdown": (_command, context) => context.dispose(),
+    "set-setting": ownedUiStateCommand,
+    "apply-customization": ownedUiStateCommand,
+    "remove-customization": ownedUiStateCommand,
+};
+/** Carries out one admitted command against the running engine; throws when no session runs or the command fails. */
+export async function performEngineCommand(command, context) {
+    const { runtime, session, generation } = context.engine;
+    if (!runtime || !session)
+        throw new Error("engine session is unavailable");
+    // Invariant: the table maps each type to the handler for exactly that command, so the command fits its own handler.
+    const handler = ENGINE_COMMANDS[command.type];
+    await handler(command, context, { runtime, session, generation });
+}

package/dist/integrations/pi/engine/host.js

@@ -86,7 +86,7 @@ class ProcessPiEngineHost {
             return;
         this.#disposed = true;
         this.#abort.abort();
-        const live = [...this.#sessions.values()].filter(session => !session.disposed);
+        const live = [...this.#sessions.values()].filter(session => !session.identity.disposed);
         this.#sessions.clear();
         await Promise.all(live.map(session => session.dispose()));
     }
@@ -107,7 +107,7 @@ class ProcessPiEngineHost {
     }
     #forgetDisposedSessions() {
         for (const [sessionId, session] of this.#sessions)
-            if (session.disposed)
+            if (session.identity.disposed)
                 this.#sessions.delete(sessionId);
     }
     // Rationale: the profile's timeout is installed once, by whichever session loads it first; a written

package/dist/integrations/pi/engine/offline-settings-port.d.ts

@@ -0,0 +1,23 @@
+import { resolvePiProjectTrustPreflight } from "./project-trust-preflight.js";
+import { PiSettingsBridge, type PiSettingKey } from "./settings-bridge.js";
+import { ModelRuntime, SettingsManager } from "../startup-public.js";
+export interface OfflinePiSettingsPortOptions {
+    readonly cwd: string;
+    readonly agentDir: string;
+    readonly resolveTrust?: typeof resolvePiProjectTrustPreflight;
+    readonly createSettingsManager?: (cwd: string, agentDir: string, projectTrusted: boolean) => SettingsManager;
+    readonly createModelRuntime?: (options: Parameters<typeof ModelRuntime.create>[0]) => Promise<Pick<ModelRuntime, "getAvailableSnapshot">>;
+}
+export interface OfflinePiSettingsPort {
+    readonly port: PiSettingsBridge;
+    readonly manager: SettingsManager;
+    /** Resolves after the local auth/model catalog has populated the per-model choices. */
+    readonly modelsReady: Promise<void>;
+}
+/**
+ * Pi settings for the resident Settings utility tab. It reads the same persisted manager as an
+ * Agent, but every bound live effect is persistence-only because each Agent process owns its effect.
+ */
+export declare function createOfflinePiSettingsPort(options: OfflinePiSettingsPortOptions): Promise<OfflinePiSettingsPort>;
+/** Keys the slim Settings port intentionally binds and exposes in bare mode. */
+export declare function offlinePiSettingKeys(): readonly PiSettingKey[];

package/dist/integrations/pi/engine/offline-settings-port.js

@@ -0,0 +1,53 @@
+import { join } from "node:path";
+import { resolvePiProjectTrustPreflight } from "./project-trust-preflight.js";
+import { PI_SETTING_EFFECTS, PiSettingsBridge, supportedThinkingLevels, } from "./settings-bridge.js";
+import { ModelRuntime, SettingsManager } from "../startup-public.js";
+const PERSIST_ONLY_OWNERS = ["shell", "startup", "agent", "terminal"];
+/**
+ * Pi settings for the resident Settings utility tab. It reads the same persisted manager as an
+ * Agent, but every bound live effect is persistence-only because each Agent process owns its effect.
+ */
+export async function createOfflinePiSettingsPort(options) {
+    let modelRuntime = null;
+    const createModelRuntime = options.createModelRuntime ?? (input => ModelRuntime.create(input));
+    const modelsReady = createModelRuntime({
+        authPath: join(options.agentDir, "auth.json"),
+        modelsPath: join(options.agentDir, "models.json"),
+        allowModelNetwork: false,
+    }).then(runtime => { modelRuntime = runtime; }, () => undefined);
+    const trust = await (options.resolveTrust ?? resolvePiProjectTrustPreflight)({
+        cwd: options.cwd,
+        agentDir: options.agentDir,
+    });
+    const manager = (options.createSettingsManager
+        ?? ((cwd, agentDir, projectTrusted) => SettingsManager.create(cwd, agentDir, { projectTrusted })))(options.cwd, options.agentDir, trust.trusted);
+    const port = new PiSettingsBridge(manager, {
+        productMode: "bare",
+        models: () => modelChoices(modelRuntime?.getAvailableSnapshot() ?? [], manager.getAllModelThinkingLevels?.() ?? {}),
+    });
+    for (const owner of PERSIST_ONLY_OWNERS)
+        port.bindOwner(owner, persistOnlyHandlers(owner));
+    return { port, manager, modelsReady };
+}
+function persistOnlyHandlers(owner) {
+    return Object.fromEntries(Object.entries(PI_SETTING_EFFECTS)
+        .filter(([, definition]) => definition.owner === owner && definition.hiddenInBare !== true)
+        .map(([key]) => [key, { apply() { } }]));
+}
+function modelChoices(models, overrides) {
+    return models.map(model => {
+        const key = `${model.provider}/${model.id}`;
+        return {
+            key,
+            label: `${model.id} [${model.provider}]`,
+            description: overrides[key] === undefined ? "global default" : `override: ${overrides[key]}`,
+            levels: supportedThinkingLevels(model),
+        };
+    });
+}
+/** Keys the slim Settings port intentionally binds and exposes in bare mode. */
+export function offlinePiSettingKeys() {
+    return Object.entries(PI_SETTING_EFFECTS)
+        .filter(([, definition]) => PERSIST_ONLY_OWNERS.includes(definition.owner) && definition.hiddenInBare !== true)
+        .map(([key]) => key);
+}

package/dist/integrations/pi/engine/pi-settings-metadata.json

@@ -15,6 +15,7 @@
     "steeringMode",
     "followUpMode",
     "transport",
+    "sessionShareDestination",
     "httpIdleTimeoutMs",
     "cacheWarmingMode",
     "hideThinkingBlock",
@@ -51,6 +52,7 @@
     "steeringMode",
     "followUpMode",
     "transport",
+    "sessionShareDestination",
     "httpIdleTimeoutMs",
     "cacheWarmingMode",
     "hideThinkingBlock",
@@ -129,7 +131,7 @@
     },
     "showHardwareCursor": {
       "label": "Show hardware cursor",
-      "description": "Show the terminal cursor while still positioning it for IME support",
+      "description": "Use the terminal cursor instead of Pi's drawn cursor",
       "opensDialog": false,
       "values": [
         "true",
@@ -297,6 +299,16 @@
         "never"
       ]
     },
+    "sessionShareDestination": {
+      "label": "Session share destination",
+      "description": "Where to upload sessions with /share (auto prefers Radius when authenticated, otherwise GitHub Gist)",
+      "opensDialog": false,
+      "values": [
+        "auto",
+        "gist",
+        "radius"
+      ]
+    },
     "doubleEscapeAction": {
       "label": "Double-escape action",
       "description": "Action when pressing Escape twice with empty editor",
@@ -388,7 +400,7 @@
         "label": "Anthropic extra usage",
         "description": "Warn when Anthropic subscription auth may use paid extra usage",
         "key": "anthropicExtraUsage",
-        "fallback": true
+        "fallback": false
       }
     ]
   },

package/dist/integrations/pi/engine/ports.d.ts

@@ -0,0 +1,56 @@
+import type { AgentSession } from "../startup-public.js";
+import type { OwnedUiExtensionPort, OwnedUiImageAttachment, OwnedUiReleaseUpdate, OwnedUiSessionCatalogPort, OwnedUiSessionIdentityPort, OwnedUiSessionPort, OwnedUiSessionSettingsPort, OwnedUiWorkflowPort } from "../../../contracts/owned-ui/index.js";
+import type { PiPinnedSettingsCallback, PiPinnedSettingsSnapshot, PiSessionSelectorContext, PiTreeSelectorContext, PiWorkflowInteractionHost, PiWorkflowRequest, PiWorkflowResult } from "./workflows.js";
+import type { PiExtensionUiBinding } from "./extension-ui-binding.js";
+import type { PiResourceCatalog } from "./resource-catalog.js";
+import type { PiEngineRuntime } from "./session-runtime.js";
+import type { PiEngineSettings } from "./settings-port.js";
+import type { PiWorkflowContexts } from "./workflow-contexts.js";
+import type { PiWorkflowRunner } from "./workflow-runner.js";
+/**
+ * The Pi objects pinned selectors and transcript renderers are built from. They are not part of the
+ * session backend contract; only the session presenters owner reads them.
+ */
+export interface PiSessionPresentationSource {
+    pinnedModelSelectorContext(): ReturnType<PiWorkflowContexts["pinnedModelSelectorContext"]>;
+    pinnedSessionSelectorContext(): PiSessionSelectorContext;
+    pinnedTreeSelectorContext(): PiTreeSelectorContext;
+    pinnedMessageRenderer(customType: string): unknown;
+    pinnedToolRenderers(toolName: string): unknown;
+    pinnedShortcutDescriptions(bindings: Parameters<AgentSession["extensionRunner"]["getShortcuts"]>[0]): readonly {
+        readonly key: string;
+        readonly description: string;
+    }[];
+    pinnedSettingsModels(): Pick<PiPinnedSettingsSnapshot, "currentModel" | "availableDefaultModels">;
+    applyPinnedSettingValue(callback: PiPinnedSettingsCallback, value: unknown): Promise<PiWorkflowResult>;
+}
+export interface PiEngineAdapterPorts {
+    readonly identity: OwnedUiSessionIdentityPort;
+    readonly session: OwnedUiSessionPort;
+    readonly workflows: OwnedUiWorkflowPort;
+    readonly settings: OwnedUiSessionSettingsPort;
+    readonly catalog: OwnedUiSessionCatalogPort;
+    readonly extensions: OwnedUiExtensionPort;
+    readonly presentation: PiSessionPresentationSource;
+}
+/** The adapter's collaborators and its own session operations, which every port member reaches at call time. */
+export interface EnginePortParts {
+    readonly sessionId: string;
+    readonly agentDir: string;
+    readonly engine: Pick<PiEngineRuntime, "cwd" | "generation" | "bindingGeneration" | "currentSessionResumeMetadata" | "currentSessionFile" | "session">;
+    readonly contexts: PiWorkflowContexts;
+    readonly workflows: PiWorkflowRunner;
+    readonly settings: PiEngineSettings;
+    readonly resources: PiResourceCatalog;
+    readonly extensions: PiExtensionUiBinding;
+    readonly session: OwnedUiSessionPort;
+    disposed(): boolean;
+    executeWorkflow(request: PiWorkflowRequest): Promise<PiWorkflowResult>;
+    clearQueuedWorkflows(): readonly string[];
+    setWorkflowInteractionHost(interaction: PiWorkflowInteractionHost): void;
+    announceReleaseUpdate(release: OwnedUiReleaseUpdate): void;
+    resolveTranscriptImage(assetId: string): OwnedUiImageAttachment | null;
+    /** The running session's extension runner; throws when no session runs. */
+    extensionRunner(): AgentSession["extensionRunner"] | undefined;
+}
+export declare function createEnginePorts(parts: EnginePortParts): PiEngineAdapterPorts;

package/dist/integrations/pi/engine/ports.js

@@ -0,0 +1,93 @@
+// Invariant: every port member delegates at call time, so ports built once follow session replacement.
+export function createEnginePorts(parts) {
+    const { engine, contexts, workflows, settings, resources, extensions } = parts;
+    return {
+        identity: {
+            sessionId: parts.sessionId,
+            agentDir: parts.agentDir,
+            get cwd() { return engine.cwd; },
+            get sessionGeneration() { return engine.generation; },
+            get sessionBindingGeneration() { return engine.bindingGeneration; },
+            get disposed() { return parts.disposed(); },
+            currentSessionResumeMetadata: () => engine.currentSessionResumeMetadata(),
+            currentSessionFile: () => engine.currentSessionFile(),
+            currentHistorySessionId: () => {
+                const id = engine.session?.sessionManager?.getSessionId?.();
+                return typeof id === "string" && id.length > 0 && id.length <= 256 && !id.includes("\0") ? id : null;
+            },
+        },
+        session: parts.session,
+        workflows: {
+            executeWorkflow: request => parts.executeWorkflow(request),
+            executeBashWorkflow: (command, excludeFromContext) => workflows.executeBashWorkflow(command, excludeFromContext),
+            cycleModelWorkflow: direction => workflows.cycleModelWorkflow(direction),
+            workflowAutocompleteCommands: () => resources.workflowAutocompleteCommands(),
+            clearQueuedWorkflows: () => parts.clearQueuedWorkflows(),
+            reloadBlockedResult: () => workflows.reloadBlockedResult(),
+            copyWorkflowText: text => workflows.copyWorkflowText(text),
+            setWorkflowInteractionHost: interaction => { parts.setWorkflowInteractionHost(interaction); },
+        },
+        settings: {
+            get productMode() { return settings.productMode; },
+            snapshot: () => {
+                // Invariant: the selector-only model values travel on the presentation source, not in the neutral snapshot.
+                const { currentModel: _currentModel, availableDefaultModels: _availableDefaultModels, ...snapshot } = settings.pinnedSettingsSnapshot();
+                return snapshot;
+            },
+            bindOwner: (owner, handlers) => settings.bindSettingsOwner(owner, handlers),
+            setDefaultThinkingLevel: level => { settings.setDefaultThinkingLevel(level); },
+            configuredTheme: () => settings.configuredTheme(),
+        },
+        catalog: {
+            modelsContext: () => contexts.modelsContext(),
+            setSessionModelScope: scopeIds => { contexts.setSessionModelScope(scopeIds); },
+            persistModelScope: scopeIds => { contexts.persistModelScope(scopeIds); },
+            refreshModels: signal => contexts.refreshModels(signal),
+            pinnedScopedModelsContext: () => contexts.pinnedScopedModelsContext(),
+            updateScopedModels: enabledModelIds => { contexts.updateScopedModels(enabledModelIds); },
+            persistScopedModels: enabledModelIds => { contexts.persistScopedModels(enabledModelIds); },
+            refreshScopedModels: signal => contexts.refreshScopedModels(signal),
+            pinnedProjectTrustContext: () => contexts.pinnedProjectTrustContext(),
+            persistProjectTrust: updates => { contexts.persistProjectTrust(updates); },
+            pinnedLoginOptions: authType => contexts.loginOptions(authType),
+            pinnedLoginMethodOptions: providerReference => contexts.pinnedLoginMethodOptions(providerReference),
+            pinnedAmbientAuthentication: selection => contexts.pinnedAmbientAuthentication(selection),
+            pinnedLogoutOptions: () => contexts.logoutOptions(),
+            pinnedForkOptions: () => contexts.pinnedForkOptions(),
+        },
+        extensions: {
+            nonVisualResources: () => resources.nonVisualResources(),
+            extensionResources: () => resources.extensionResources(),
+            resolveTranscriptImage: assetId => parts.resolveTranscriptImage(assetId),
+            visualExtensionSupport: () => extensions.support(),
+            bindExtensionUi: (ui, shutdown) => extensions.bind(ui, shutdown),
+            unbindExtensionUi: () => extensions.unbind(),
+            bindClipboardWriter: writer => workflows.bindClipboardWriter(writer),
+            announceReleaseUpdate: release => { parts.announceReleaseUpdate(release); },
+        },
+        presentation: {
+            pinnedModelSelectorContext: () => contexts.pinnedModelSelectorContext(),
+            pinnedSessionSelectorContext: () => contexts.pinnedSessionSelectorContext(),
+            pinnedTreeSelectorContext: () => contexts.pinnedTreeSelectorContext(),
+            pinnedMessageRenderer: customType => parts.extensionRunner()?.getMessageRenderer?.(customType),
+            pinnedToolRenderers: toolName => {
+                const runner = parts.extensionRunner();
+                if (runner === undefined)
+                    return undefined;
+                if (typeof runner.resolveToolRenderers === "function") {
+                    return runner.resolveToolRenderers(toolName, () => runner.getToolDefinition?.(toolName));
+                }
+                return runner.getToolDefinition?.(toolName);
+            },
+            pinnedShortcutDescriptions: bindings => {
+                const shortcuts = parts.extensionRunner()?.getShortcuts?.(bindings);
+                return shortcuts === undefined ? [] : [...shortcuts].map(([key, shortcut]) => ({ key, description: shortcut.description ?? shortcut.extensionPath }));
+            },
+            pinnedSettingsModels: () => {
+                const { currentModel, availableDefaultModels } = settings.pinnedSettingsSnapshot();
+                return { ...(currentModel === undefined ? {} : { currentModel }), availableDefaultModels };
+            },
+            applyPinnedSettingValue: (callback, value) => settings.applyPinnedSettingValue(callback, value),
+        },
+    };
+}

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

@@ -26,5 +26,6 @@ export declare class PiPromptSuggestions implements OwnedUiPromptSuggestionGener
     #private;
     constructor(ports: PiPromptSuggestionPorts);
     reasoningPolicy(): OwnedUiPromptSuggestionReasoning;
+    completeInstruction(instruction: string, maxTokens: number, signal: AbortSignal): Promise<string | null>;
     generate(request: OwnedUiPromptSuggestionRequest): Promise<OwnedUiPromptSuggestionResult>;
 }

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

@@ -20,6 +20,46 @@ export class PiPromptSuggestions {
         // Performance: the run's own level keeps the provider's thinking parameters, and the cached prefix, identical.
         return readSuggestionReasoning(session.thinkingLevel);
     }
+    async completeInstruction(instruction, maxTokens, signal) {
+        const session = this.#ports.session();
+        const runtime = this.#ports.runtime();
+        if (this.#ports.unavailable() || session === undefined || runtime === undefined || signal.aborted
+            || session.model === undefined || typeof runtime.services.modelRuntime.completeSimple !== "function")
+            return null;
+        const agent = session.agent;
+        try {
+            const transformed = typeof agent.transformContext === "function"
+                ? await agent.transformContext(agent.state.messages, signal)
+                : agent.state.messages;
+            const messages = typeof agent.convertToLlm === "function"
+                ? await agent.convertToLlm(transformed)
+                : transformed.filter(message => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
+            const response = await runtime.services.modelRuntime.completeSimple(session.model, {
+                systemPrompt: agent.state.systemPrompt,
+                messages: [...messages, { role: "user", content: instruction, timestamp: Date.now() }],
+                tools: [],
+            }, {
+                signal,
+                maxTokens,
+                ...(agent.sessionId === undefined ? {} : { sessionId: agent.sessionId }),
+                ...(agent.transport === undefined ? {} : { transport: agent.transport }),
+                ...(agent.onPayload === undefined ? {} : { onPayload: agent.onPayload }),
+            });
+            if (signal.aborted || !isRecord(response) || response.stopReason === "aborted"
+                || response.stopReason === "error" || response.stopReason === "length"
+                || stringValue(response.errorMessage) !== undefined)
+                return null;
+            const content = Array.isArray(response.content) ? response.content : [];
+            if (content.some(block => isRecord(block) && block.type === "toolCall"))
+                return null;
+            const text = content.filter(block => isRecord(block) && block.type === "text")
+                .map(block => stringValue(block.text) ?? "").join("\n").trim();
+            return text || null;
+        }
+        catch {
+            return null;
+        }
+    }
     async generate(request) {
         assertOwnedUiPromptSuggestionRequest(request);
         const identity = request.identity;