@timurproko/a1 0.2.7-dev.808 → 0.2.7-dev.810

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/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">;
+    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,89 @@
+// 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(),
+        },
+        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),
+        },
+    };
+}