pi2dsh 0.12.3 → 0.13.0

package/dist/runtime.d.mts

@@ -1,14 +1,568 @@
 
+import { N as Theme, p as ExtensionRunner } from "./pi-coding-agent-B0PT23gE.mjs";
 import { a as GeneratedRuntimeManifest } from "./types-7IWJPPvS.mjs";
+import { EventEmitter } from "node:events";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { ContentBlock } from "@deepseek-ai/dsh-llm";
 import { Context } from "@deepseek-ai/cordis";
+//#region src/capability.d.ts
+type PackageHealthStatus = 'ok' | 'degraded' | 'unusable';
+interface PackageHealth {
+  status: PackageHealthStatus;
+  /** Pi capability names this package has hit, in first-hit order. */
+  gaps: readonly string[];
+}
+interface CapabilityGapOptions {
+  /** The Pi capability, as the package sees it (e.g. "ctx.fork"). */
+  capability: string;
+  /** Why DSH has no mapping, in one sentence. */
+  reason: string;
+  /** What the caller can do about it, in one sentence. */
+  guidance: string;
+  /** The migrated package that hit the gap, when known. */
+  packageName?: string;
+}
+/**
+ * Host-level record of capability gaps, one instance per DSH host (it lives in
+ * SharedHostState). Emits ONE user-facing notice per (package, capability):
+ * repeated hits of the same gap change nothing the user needs to hear again.
+ */
+declare class CapabilityLedger {
+  private readonly emit;
+  private readonly noticed;
+  private readonly packages;
+  constructor(emit: (message: string) => void);
+  /**
+   * Record a degraded capability: this feature of the package does not work on
+   * DSH, the rest of the package keeps working. Reported to the user once.
+   */
+  reportDegraded(options: CapabilityGapOptions): void;
+  /**
+   * Record a host-owned decision (e.g. shutdown): the host refused or absorbed
+   * the request through a channel Pi itself defines. Not a package defect, so
+   * package health stays untouched; the user still learns what happened, once.
+   */
+  reportHostDecision(options: CapabilityGapOptions): void;
+  /**
+   * Startup-time reference detection: the package's source imports a
+   * host-owned symbol that cannot work on DSH. Reported at mount so the user
+   * learns BEFORE any code path runs into it; health is untouched because an
+   * import alone proves nothing about usage — construction still fails
+   * structurally and marks the package then.
+   */
+  reportStartupReference(options: CapabilityGapOptions): void;
+  /**
+   * Record that a package could not even mount because its entry code needs a
+   * missing capability. The package is marked unusable for this run.
+   */
+  reportUnusable(options: CapabilityGapOptions): void;
+  healthOf(packageName: string): PackageHealth;
+  /** Every package with a recorded gap, for surfacing in mount summaries. */
+  snapshot(): ReadonlyMap<string, PackageHealth>;
+  private mark;
+  private notice;
+}
+//#endregion
+//#region src/session-bridge.d.ts
+type UnknownRecord$4 = Record<string, unknown>;
+interface DshSessionLike {
+  id: string;
+  events: readonly UnknownRecord$4[] | (() => readonly UnknownRecord$4[]);
+  append?(type: string, data: unknown, opts?: unknown): unknown;
+  header?: UnknownRecord$4;
+}
+interface PiProjectedEntry {
+  type: string;
+  id: string;
+  parentId: string | null;
+  timestamp: string;
+  [key: string]: unknown;
+}
+declare class PiSessionBridge {
+  private readonly records;
+  private readonly loaded;
+  private sidecarPath;
+  load(sessionId: string): void;
+  private persist;
+  appendCustomEntry(sessionId: string, customType: string, data: unknown): string;
+  /**
+   * The custom entries a package appended to one session, oldest first.
+   *
+   * Addressed by id alone: the browser half asks for a session it is showing,
+   * and has no DSH session object to hand over.
+   * @param sessionId - session whose sidecar to read.
+   * @returns each custom entry with its type, data and id.
+   */
+  customEntries(sessionId: string): Array<{
+    id: string;
+    customType: string;
+    data: unknown;
+    timestamp: string;
+  }>;
+  appendBranchSummary(sessionId: string, summary: string, fromId: string): string;
+  appendLabel(sessionId: string, targetId: string, label: string | undefined): void;
+  setName(sessionId: string, name: string): void;
+  getName(sessionId: string): string | undefined;
+  labels(sessionId: string): Map<string, string>;
+  /**
+   * Project the DSH durable log plus sidecar records into Pi's entry-chain
+   * shape. DSH history is linear, so the projection is a single-branch tree:
+   * every entry's parent is its predecessor.
+   */
+  /**
+   * The seqs still on the model-visible surface, via DSH's own canonical fold.
+   * @param session - the session to project.
+   * @returns the visible seqs, or undefined when the fold cannot run (a
+   *   projection built from a partial event list, e.g. in a test double) — in
+   *   which case nothing is filtered out rather than everything.
+   */
+  visibleSeqs(session: DshSessionLike): Set<number> | undefined;
+  projectEntries(session: DshSessionLike): PiProjectedEntry[];
+  /** The exact 14-method surface Pi exposes as ctx.sessionManager. */
+  readonlySessionManager(session: DshSessionLike, cwd: string): UnknownRecord$4;
+}
+//#endregion
+//#region src/subagent-bridge.d.ts
+type UnknownRecord$3 = Record<string, unknown>;
+type PiSessionEventHandler = (event: UnknownRecord$3) => void;
+interface SubagentHost {
+  cordis: Context;
+  cwd(): string;
+  parentSessionId(): string | undefined;
+  /** The delegating parent's delegation depth (DSH's recursion budget); 0 for a top-level parent. */
+  parentDelegationDepth(): number;
+  piContentToDsh(content: unknown): Promise<ContentBlock[]>;
+  deliver(agent: UnknownRecord$3, message: unknown, mode: 'inject' | 'steer' | 'followup'): void;
+  messageFromSessionEvent(event: UnknownRecord$3): Promise<UnknownRecord$3 | undefined>;
+  messageSource: string;
+  /** The Pi package that asked for the child, used to label it in DSH's catalog. */
+  packageName?: string;
+}
+interface BeforeToolCallDecision {
+  block?: boolean;
+  reason?: string;
+}
+interface PiSubagentFacade {
+  beforeToolCall?: (context: {
+    toolCall: {
+      name: string;
+      id: string;
+      arguments: unknown;
+    };
+  }, signal: AbortSignal | undefined) => Promise<BeforeToolCallDecision | undefined> | BeforeToolCallDecision | undefined;
+  /** Pi's AgentState — the same object `session.state` returns. */
+  state?: UnknownRecord$3;
+}
+declare class PiBridgedAgentSession {
+  #private;
+  readonly agent: PiSubagentFacade;
+  readonly messages: UnknownRecord$3[];
+  constructor(host: SubagentHost, handle: {
+    agent: UnknownRecord$3;
+    dispose(): Promise<void>;
+  }, tools: unknown[]);
+  /** Pi's AgentState projection, shared by `session.state` and `session.agent.state`. */
+  get state(): UnknownRecord$3;
+  /**
+   * Whether one transcript entry is carried context rather than part of the
+   * exchange in this child session.
+   * @param message - an entry of {@link messages}.
+   * @returns true for a seeded transcript entry or a host runtime snapshot.
+   */
+  isCarriedContext(message: UnknownRecord$3): boolean;
+  subscribe(handler: PiSessionEventHandler): () => void;
+  prompt(text: string): Promise<void>;
+  steer(text: string): void;
+  abort(): void;
+  setSessionName(name: string): void;
+  getSessionName(): string;
+  getSessionStats(): UnknownRecord$3;
+  getAllTools(): unknown[];
+  getActiveToolNames(): string[];
+  setActiveToolsByName(names: string[]): void;
+  bindExtensions(_bindings?: UnknownRecord$3): Promise<void>;
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/browser-surfaces.d.ts
+/** One side thread as the panel renders it. */
+interface PanelThreadView {
+  /** The child session's id, stable for the life of the thread. */
+  id: string;
+  /** Human label, already the one DSH's catalog shows. */
+  label: string;
+  /** Pi package that opened it, when known. */
+  package?: string;
+  /** Whether the child is mid-turn. */
+  running: boolean;
+  messages: Array<{
+    role: string;
+    text: string;
+  }>;
+}
+interface TrackedThread {
+  id: string;
+  label: string;
+  package: string | undefined;
+  session: PiBridgedAgentSession;
+}
+/**
+ * Live side threads, keyed by the parent session they belong to.
+ *
+ * Host-level (one per engine instance, like the provider directory): the panel
+ * is one surface, however many Pi packages contribute threads to it.
+ */
+declare class BrowserSurfaces {
+  #private;
+  /** Register one known image tool's exact DSH wire name. */
+  registerImageTool(name: string): void;
+  /** Exact wire names needing the generic Pi image-result browser view. */
+  imageToolNames(): string[];
+  /**
+   * Track one child session under its parent.
+   * @param parentSessionId - the session the panel floats over.
+   * @param thread - the child's identity and live session object.
+   * @returns a disposer that removes the thread from the panel.
+   */
+  track(parentSessionId: string, thread: TrackedThread): () => void;
+  /**
+   * The panel's view of one parent session.
+   * @param parentSessionId - session the browser is currently showing.
+   * @returns every side thread opened under it, oldest first.
+   */
+  snapshot(parentSessionId: string): PanelThreadView[];
+  /**
+   * Pi's `setStatus(key, text)`: one keyed status entry in the status bar.
+   * The key is the entry's identity; passing undefined removes that entry,
+   * exactly like Pi clears one status.
+   * @param sessionId - session the calling agent belongs to.
+   * @param packageName - Pi package making the call, when known.
+   * @param key - the status entry's key.
+   * @param text - the text to show, or undefined to remove the entry.
+   */
+  setStatus(sessionId: string, packageName: string | undefined, key: string, text: unknown): void;
+  /**
+   * Pi's `setWidget(key, content)`: one keyed widget. Only string arrays are
+   * recorded — anything else is ignored exactly like Pi's own rpc mode, where
+   * widgets are transmitted to a host as lines and factory content needs TUI
+   * access the host never provides.
+   * @param sessionId - session the calling agent belongs to.
+   * @param packageName - Pi package making the call, when known.
+   * @param key - the widget's key.
+   * @param content - the widget's lines, or undefined to remove the widget.
+   */
+  setWidget(sessionId: string, packageName: string | undefined, key: string, content: unknown, theme?: unknown): void;
+  /**
+   * Record one simple presentation call (working chrome, title, header,
+   * footer). The value is a string, a Pi component, a working-indicator
+   * options object, or a header/footer factory; each renders to text here so
+   * the browser half never runs Pi code.
+   * @param sessionId - session the calling agent belongs to.
+   * @param packageName - Pi package making the call, when known.
+   * @param key - which surface.
+   * @param value - the value the package passed; undefined clears it.
+   * @param theme - the bridge's headless theme, for factories that style with it.
+   */
+  setSurface(sessionId: string, packageName: string | undefined, key: SurfaceKey, value: unknown, theme?: unknown): void;
+  /**
+   * Pi's `setWorkingVisible`: hide the working chrome without forgetting it.
+   * @param sessionId - session the calling agent belongs to.
+   * @param packageName - Pi package making the call, when known.
+   * @param visible - whether the working chrome should show.
+   */
+  setWorkingVisible(sessionId: string, packageName: string | undefined, visible: boolean): void;
+  /**
+   * Register one package's custom-entry renderer.
+   *
+   * Pulled rather than pushed: a renderer's output depends on the session being
+   * looked at, and the package registers once at mount for every session it
+   * will ever be asked about.
+   * @param packageName - owning Pi package.
+   * @param source - called with the session id the browser is showing.
+   * @returns a disposer that unregisters the source.
+   */
+  trackEntries(packageName: string, source: EntrySource): () => void;
+  /**
+   * Custom entries every package renders for one session, in package order.
+   * @param sessionId - session the browser is showing.
+   * @returns rendered entries; a renderer that throws contributes nothing.
+   */
+  entries(sessionId: string): RenderedEntry[];
+  /**
+   * Ask the browser to put text in the composer.
+   *
+   * A revision rather than a flag: the seat applies a request once, and the
+   * next call — even with identical text — is a new request rather than a
+   * no-op, which is what a package retrying a paste means.
+   * @param sessionId - session whose composer to write.
+   * @param text - the full next draft.
+   */
+  requestDraft(sessionId: string, text: string): void;
+  /**
+   * The pending composer write for one session, if any.
+   * @param sessionId - session the browser is showing.
+   * @returns the request, or undefined when nothing is pending.
+   */
+  draftRequest(sessionId: string): DraftRequest | undefined;
+  /**
+   * Record what the composer actually holds, as reported by the browser.
+   * @param sessionId - session the report is about.
+   * @param text - the live draft.
+   */
+  reportDraft(sessionId: string, text: string): void;
+  /**
+   * The composer text for one session.
+   * @param sessionId - session to read.
+   * @returns the browser's last report, or the last requested text.
+   */
+  liveDraft(sessionId: string): string;
+  /**
+   * Register one package's completion provider.
+   * @param packageName - owning Pi package.
+   * @param source - asked with the trigger character and the typed query.
+   * @returns a disposer that unregisters the source.
+   */
+  trackCompletions(packageName: string, source: CompletionSource): () => void;
+  /**
+   * Completions every package offers for one trigger token.
+   * @param trigger - the trigger character the menu opened on.
+   * @param query - what the user has typed after it.
+   * @returns candidates in package order; a provider that throws contributes none.
+   */
+  completions(trigger: string, query: string): Promise<CompletionItem[]>;
+  /**
+   * What packages have put on screen for one session.
+   * @param sessionId - session the browser is showing.
+   * @returns one entry per package that has driven a surface, empties dropped.
+   */
+  surfaces(sessionId: string): SurfaceView[];
+}
+/**
+ * Presentation slots a Pi package can drive, in DSH's browser shell. The
+ * keyed surfaces (status, widget) live on {@link SurfaceView.statuses} and
+ * {@link SurfaceView.widgets}; the simple ones live in `values`.
+ */
+type SurfaceKey = 'workingMessage' | 'workingIndicator' | 'hiddenThinkingLabel' | 'title' | 'header' | 'footer';
+/** One package's presentation state for one session. */
+interface SurfaceView {
+  package?: string;
+  /** Simple string surfaces: working chrome, transient title, header, footer. */
+  values: Partial<Record<SurfaceKey, string>>;
+  /** Pi's `setStatus` entries, keyed by the entry key. */
+  statuses: Record<string, string>;
+  /** Pi's `setWidget` entries, keyed by the widget key. */
+  widgets: Record<string, string>;
+  /** Pi's setWorkingVisible: false hides the working chrome without clearing it. */
+  workingVisible: boolean;
+}
+/** One custom entry a package rendered for the conversation. */
+interface RenderedEntry {
+  id: string;
+  customType: string;
+  package?: string;
+  text: string;
+}
+/** One pending composer write, with the revision the browser acknowledges. */
+interface DraftRequest {
+  text: string;
+  rev: number;
+}
+/** One completion a Pi provider offered for a trigger token. */
+interface CompletionItem {
+  value: string;
+  label: string;
+  description?: string;
+}
+/** A package's completion provider, asked with the token the user is typing. */
+type CompletionSource = (trigger: string, query: string) => Promise<CompletionItem[]>;
+/** A package's renderer, pulled at snapshot time for the session on screen. */
+type EntrySource = (sessionId: string) => RenderedEntry[];
+//#endregion
+//#region src/compat/vendor/pi-ai-credential-store.d.ts
+/**
+ * Default in-memory credential store. Apps inject persistent stores.
+ * Keyed by `Provider.id`, one credential per provider; see `CredentialStore`.
+ * Writes are serialized per provider through a promise chain.
+ */
+declare class InMemoryCredentialStore {
+  credentials: Map<any, any>;
+  chains: Map<any, any>;
+  /** Serialize tasks per provider id without releasing the chain before active work settles. */
+  enqueue(providerId: any, task: any, options: any): Promise<unknown>;
+  read(providerId: any, options: any): Promise<any>;
+  list(options: any): Promise<{
+    providerId: any;
+    type: any;
+  }[]>;
+  modify(providerId: any, fn: any, options: any): Promise<unknown>;
+  delete(providerId: any, options: any): Promise<unknown>;
+}
+//#endregion
+//#region src/oauth-bridge.d.ts
+type UnknownRecord$2 = Record<string, unknown>;
+declare class FileCredentialStore extends InMemoryCredentialStore {
+  #private;
+  constructor(path: string);
+  get path(): string;
+  modify(providerId: string, fn: (current: unknown) => unknown, options?: UnknownRecord$2): Promise<unknown>;
+  delete(providerId: string, options?: UnknownRecord$2): Promise<void>;
+}
+//#endregion
+//#region src/model-bridge.d.ts
+type UnknownRecord$1 = Record<string, unknown>;
+interface DshLlmLike {
+  listProviders(): Array<{
+    id: string;
+    name: string;
+  }>;
+  listModels(provider: string): Promise<UnknownRecord$1[]>;
+  resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<UnknownRecord$1>;
+  stream(options: UnknownRecord$1): AsyncIterable<UnknownRecord$1>;
+}
+/** A DSH catalog entry in Pi's Model shape. */
+interface PiModelShape {
+  id: string;
+  name: string;
+  provider: string;
+  api: string;
+  input: Array<'text' | 'image'>;
+  reasoning: boolean;
+  contextWindow?: number;
+  maxTokens?: number;
+  [key: string]: unknown;
+}
+/**
+ * Cached projection of DSH's advisory model catalog as Pi Model objects.
+ * `refresh()` re-reads providers and models; the runtime subscribes it to
+ * `llm/adapters-updated`. Reads are synchronous (Pi's getAll contract).
+ */
+declare class ModelCatalog {
+  #private;
+  constructor(llm: DshLlmLike | undefined);
+  get present(): boolean;
+  all(): PiModelShape[];
+  find(provider: string, modelId: string): PiModelShape | undefined;
+  refresh(): Promise<void>;
+  /** Exact-route metadata (context window, reasoning efforts), cached per route. */
+  resolve(provider: string, modelId: string): Promise<PiModelShape | undefined>;
+}
+//#endregion
+//#region src/provider-adapter.d.ts
+/**
+ * A registered route's disposer, plus the ability to announce it again.
+ *
+ * A package's model list is not always known when the route is registered:
+ * gateway discovery needs a credential, and a credential may only arrive later
+ * (a `/login` mid-session). DSH publishes `llm/adapters-updated` when a route
+ * set is committed, and every directory observer — the browser's model picker
+ * included — refreshes on exactly that event. So a later discovery needs the
+ * route ANNOUNCED again, or the models exist and nobody looks.
+ */
+interface PiRouteHandle {
+  (): void;
+  /** Re-commit this route so directory observers re-read its models. */
+  reannounce?(): void;
+}
+//#endregion
 //#region src/runtime.d.ts
 type UnknownRecord = Record<string, unknown>;
+type PiHandler = (event: UnknownRecord, context: UnknownRecord) => unknown | Promise<unknown>;
+declare function isKnownImageTool(packageName: string, toolName: string): boolean;
 interface RuntimeOptions {
   rootUrl: URL;
   manifest: GeneratedRuntimeManifest;
   config?: UnknownRecord;
 }
+interface PiTool {
+  name: string;
+  label?: string;
+  description: string;
+  parameters: unknown;
+  /** Pi: one line for the system prompt's "Available tools" list. */
+  promptSnippet?: string;
+  /** Pi: guideline bullets that apply while this tool is active. */
+  promptGuidelines?: string[];
+  executionMode?: 'parallel' | 'sequential';
+  prepareArguments?: (args: unknown) => unknown;
+  execute(toolCallId: string, args: unknown, signal: AbortSignal | undefined, onUpdate: ((result: unknown) => void) | undefined, context: UnknownRecord): Promise<unknown>;
+}
+interface PiCommand {
+  name: string;
+  description: string;
+  argumentHint?: string;
+  handler(args: string, context: UnknownRecord): unknown | Promise<unknown>;
+}
+interface RuntimeState {
+  packageName: string;
+  handlers: Map<string, PiHandler[]>;
+  tools: Map<string, PiTool>;
+  runner: ExtensionRunner;
+  toolDisposers: Map<string, () => void>;
+  toolRestrictions: WeakMap<object, () => void>;
+  pendingActiveTools?: string[];
+  commands: Map<string, PiCommand>;
+  commandDisposers: Map<string, () => void>;
+  flags: Map<string, boolean | string | undefined>;
+  notifications: string[];
+  activeAgents: Set<UnknownRecord>;
+  disposedAgents: WeakSet<object>;
+  currentSystemPrompt: string;
+  messageSource: string;
+  eventBus: EventEmitter;
+  agentScope: AsyncLocalStorage<UnknownRecord | undefined>;
+  bridge: PiSessionBridge;
+  theme: Theme;
+  shortcuts: Map<string, UnknownRecord>;
+  messageRenderers: Map<string, unknown>;
+  entryRenderers: Map<string, unknown>;
+  markdownTransformer?: unknown;
+  providers: Map<string, UnknownRecord>;
+  autocompleteProviders: unknown[];
+  editorComponentFactory?: unknown;
+  editorBuffers: WeakMap<object, string>;
+  toolsExpanded: boolean;
+  modelOverrides: WeakMap<object, {
+    provider?: string;
+    model?: string;
+  }>;
+  thinkingLevels: WeakMap<object, string>;
+  turnSystemPromptOverrides: WeakMap<object, string>;
+  /**
+   * The single ordered stream for projections that must keep durable-log
+   * order. Several of them now await the attachment service (Pi's content
+   * blocks carry image bytes inline), and the subscribers that feed them are
+   * synchronous — without one shared chain a tool result with an image can be
+   * announced after the turn that produced it has already ended.
+   */
+  projection: Promise<unknown>;
+  /**
+   * Pi's `terminate` hint, accumulated across the current tool batch. Pi stops
+   * the loop only when EVERY finalized call in the batch asked for it, and a
+   * single call cannot know that — so the calls record here and the next step
+   * boundary reads the verdict.
+   */
+  terminateBatch: WeakMap<object, {
+    calls: number;
+    terminating: number;
+  }>;
+  /** Pi's turnIndex: reset when a DSH turn opens, incremented after each step. */
+  piTurnIndex: WeakMap<object, number>;
+  /** Messages DSH claimed for the step that is about to be assembled. */
+  claimedForStep: WeakMap<object, UnknownRecord[]>;
+  /** The turn each agent's before_agent_start has already fired for. */
+  promptedTurn: WeakMap<object, number>;
+  /** Custom messages a before_agent_start handler returned, awaiting the step. */
+  pendingInjections: WeakMap<object, UnknownRecord[]>;
+  globalThinkingLevel: string;
+  argMutations: WeakMap<object, unknown>;
+  streamingTexts: Map<string, string>;
+  lastLoggedModels: WeakMap<object, string>;
+  modelCatalog?: ModelCatalog;
+  companionRoutes: Map<string, string>;
+  providerRouteDisposers: Map<string, PiRouteHandle>;
+  publishedOAuthKeys: Map<string, string>;
+  shared: SharedHostState;
+}
 declare function textBlocks(content: unknown): Array<{
   type: 'text';
   text: string;
@@ -47,6 +601,31 @@ declare function compactionReason(data: UnknownRecord): 'manual' | 'threshold' |
  * @param content - the DSH blocks to project.
  */
 declare function dshToPiContent(ctx: Context, content: readonly ContentBlock[]): Promise<Array<UnknownRecord>>;
+interface SharedHostState {
+  companionRoutes: Map<string, string>;
+  providerRouteDisposers: Map<string, PiRouteHandle>;
+  publishedOAuthKeys: Map<string, string>;
+  providers: Map<string, UnknownRecord>;
+  modelCatalog?: ModelCatalog;
+  catalogSubscribed?: boolean;
+  loginRegistered?: boolean;
+  oauthRefreshHooked?: boolean;
+  companionSweepSubscribed?: boolean;
+  oauthStore?: FileCredentialStore;
+  capabilityLedger?: CapabilityLedger;
+  packageRemounts?: Map<string, () => Promise<void>>;
+  browserSurfaces?: BrowserSurfaces;
+  browserSurfacesRouted?: boolean;
+  activeLogin?: ActiveLogin | undefined;
+}
+interface ActiveLogin {
+  providerName: string;
+  controller: AbortController;
+  /** Settles when the flow has released its callback port. */
+  finished: Promise<void>;
+  /** Short links this flow published, retired when it ends. */
+  published: string[];
+}
 /** Companion configuration: default (auto), `false` (off), or an explicit narrow map. */
 type VisionCompanionsConfig = false | Record<string, readonly string[]> | undefined;
 /**
@@ -67,16 +646,37 @@ type VisionCompanionsConfig = false | Record<string, readonly string[]> | undefi
  * (companionRoutes). Idempotent per host.
  */
 declare function registerVisionCompanions(ctx: Context, config: VisionCompanionsConfig): void;
+/**
+ * Turn what the user answered into one of the offered options.
+ * @param answer - the label, a differently-cased label, or a 1-based position.
+ * @param offered - the options as they were shown, in order.
+ * @returns the matching option, or undefined when nothing matches.
+ */
+declare function resolveOfferedChoice(answer: string, offered: readonly string[]): string | undefined;
+/**
+ * Cancel the login already in flight, if any, and wait for it to let go.
+ *
+ * Waiting matters: the next flow binds the same fixed callback port, and Pi's
+ * flow answers a taken port by silently degrading to a listener that never
+ * receives a code. Starting the new flow before the old one has closed
+ * reproduces exactly that.
+ * @param state - the mounting package's state, holding the shared host state.
+ * @returns the cancelled provider's name, or undefined when nothing was running.
+ */
+declare function supersedeActiveLogin(state: RuntimeState): Promise<string | undefined>;
 declare function splitArguments(input: string): string[];
 declare function expandPrompt(text: string, rawInput: string): string;
 declare function applyPiPackage(ctx: Context, options: RuntimeOptions): Promise<void>;
 declare const runtimeInternals: {
   compactionReason: typeof compactionReason;
+  resolveOfferedChoice: typeof resolveOfferedChoice;
   dshToPiContent: typeof dshToPiContent;
   expandPrompt: typeof expandPrompt;
+  isKnownImageTool: typeof isKnownImageTool;
   isSubagentOrigin: typeof isSubagentOrigin;
   normalizeToolResult: typeof normalizeToolResult;
   splitArguments: typeof splitArguments;
+  supersedeActiveLogin: typeof supersedeActiveLogin;
   textBlocks: typeof textBlocks;
 };
 //#endregion

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/runtime.ts"],"mappings":";;;;;KAuCK,gBAAgB;UAGX;EACR,SAAS;EACT,UAAU;EACV,SAAS;;iBAkLF,WAAW,mBAAmB;EAAQ;EAAc;;iBAcpD,oBAAoB,kBAAkB;iBAuH/B,oBAAoB;EAAoB,QAAQ;EAAe;;iBA8EtE,iBAAiB,SAAS;;;;;;;;;;;;;;;;iBAquB1B,iBAAiB,MAAM;;;;;;;;;;;;iBAgBjB,eAAe,KAAK,SAAS,kBAAkB,iBAAiB,QAAQ,MAAM;;KA+tBjF,iCAAiC;;;;;;;;;;;;;;;;;;iBAmB7B,yBAAyB,KAAK,SAAS,QAAQ;iBAo6BtD,eAAe;iBA+Bf,aAAa,cAAc;iBA2Id,eAAe,KAAK,SAAS,SAAS,iBAAiB;cAqMhE"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/capability.ts","../src/session-bridge.ts","../src/subagent-bridge.ts","../src/browser-surfaces.ts","../src/compat/vendor/pi-ai-credential-store.ts","../src/oauth-bridge.ts","../src/model-bridge.ts","../src/provider-adapter.ts","../src/runtime.ts"],"mappings":";;;;;;;;KAkBY;UAEK;EACf,QAAQ;;EAER;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;;cAgCW;mBAIkB;mBAHZ;mBACA;EAEY,YAAA,OAAO;;;;;EAMpC,eAAe,SAAS;;;;;;EAcxB,mBAAmB,SAAS;;;;;;;;EAa5B,uBAAuB,SAAS;;;;;EAYhC,eAAe,SAAS;EASxB,SAAS,sBAAsB;;EAO/B,YAAY,oBAAoB;UAQxB;UAQA;;;;KC5HL,kBAAgB;UAEX;EACR;EACA,iBAAiB,oCAAkC;EACnD,QAAQ,cAAc,eAAe;EACrC,SAAS;;UAgBM;EACf;EACA;EACA;EACA;GACC;;cA0BU;mBACM;mBACA;UAET;EAKR,KAAK;UAqBG;EASR,kBAAkB,mBAAmB,oBAAoB;;;;;;;;;EAiBzD,cAAc,oBAAoB;IAAQ;IAAY;IAAoB;IAAe;;EAWzF,oBAAoB,mBAAmB,iBAAiB;EAQxD,YAAY,mBAAmB,kBAAkB;EAOjD,QAAQ,mBAAmB;EAK3B,QAAQ;EASR,OAAO,oBAAoB;;;;;;;;;;;;;EAuB3B,YAAY,SAAS,iBAAiB;EAQtC,eAAe,SAAS,iBAAiB;;EAyFzC,uBAAuB,SAAS,gBAAgB,cAAc;;;;KCjS3D,kBAAgB;KAChB,yBAAyB,OAAO;UAepB;EACf,QAAQ;EACR;EACA;;EAEA;EACA,eAAe,mBAAmB,QAAQ;EAC1C,QAAQ,OAAO,iBAAe,kBAAkB;EAChD,wBAAwB,OAAO,kBAAgB,QAAQ;EACvD;;EAEA;;UAYQ;EACR;EACA;;UAGQ;EACR,kBACE;IAAW;MAAY;MAAc;MAAY;;KACjD,QAAQ,4BACL,QAAQ,sCAAsC;;EAEnD,QAAQ;;cAuBG;;WACF,OAAO;WACP,UAAU;EA4BjB,YAAA,MAAM,cACN;IAAU,OAAO;IAAe,WAAW;KAC3C;;MA2DE,SAAS;;;;;;;EA0Bb,iBAAiB,SAAS;EAgF1B,UAAU,SAAS;EAKb,OAAO,eAAe;EAkD5B,MAAM;EASN;EAYA,eAAe;EAIf;EAIA,mBAAmB;EAInB;EAIA;EAIA,qBAAqB;EAIf,eAAe,YAAW,kBAAqB;EAM/C,WAAW;;;;;UC1VF;;EAEf;;EAEA;;EAEA;;EAEA;EACA,UAAU;IAAQ;IAAc;;;UAGxB;EACR;EACA;EACA;EACA,SAAS;;;;;;;;cAwBE;;;EAmBX,kBAAkB;;EAKlB;;;;;;;EAUA,MAAM,yBAAyB,QAAQ;;;;;;EAiBvC,SAAS,0BAA0B;;;;;;;;;;EA+BnC,UAAU,mBAAmB,iCAAiC,aAAa;;;;;;;;;;;EAkB3E,UAAU,mBAAmB,iCAAiC,aAAa,kBAAkB;;;;;;;;;;;;EA6B7F,WACE,mBACA,iCACA,KAAK,YACL,gBACA;;;;;;;EAeF,kBAAkB,mBAAmB,iCAAiC;;;;;;;;;;;EAetE,aAAa,qBAAqB,QAAQ;;;;;;EAU1C,QAAQ,oBAAoB;;;;;;;;;;EAsB5B,aAAa,mBAAmB;;;;;;EAehC,aAAa,oBAAoB;;;;;;EASjC,YAAY,mBAAmB;;;;;;EAU/B,UAAU;;;;;;;EAUV,iBAAiB,qBAAqB,QAAQ;;;;;;;EAWxC,YAAY,iBAAiB,gBAAgB,QAAQ;;;;;;EAkB3D,SAAS,oBAAoB;;;;;;;KAsCnB;;UAKK;EACf;;EAEA,QAAQ,QAAQ,OAAO;;EAEvB,UAAU;;EAEV,SAAS;;EAET;;;UA4De;EACf;EACA;EACA;EACA;;;UAIe;EACf;EACA;;;UAIe;EACf;EACA;EACA;;;KAIU,oBAAoB,iBAAiB,kBAAkB,QAAQ;;KAG/D,eAAe,sBAAsB;;;;;;;;cCvdpC;EACT,aAAW;EACX,QAAM;;EAEN,QAAQ,iBAAY,WAAM,eAAO;EAgB3B,KAAK,iBAAY,eAAO;EAIxB,KAAK,eAAO;;;;EAIlB,OAAO,iBAAY,SAAI,eAAO;EAU9B,OAAO,iBAAY,eAAO;;;;KCtCzB,kBAAgB;cAiBR,4BAA4B;;EAG3B,YAAA;MAaR;EAeK,OAAO,oBAAoB,KAAK,8BAA8B,UAAU,kBAAgB;EAcxF,OAAO,oBAAoB,UAAU,kBAAgB;;;;KC7C3D,kBAAgB;UAEJ;EACf,iBAAiB;IAAQ;IAAY;;EACrC,WAAW,mBAAmB,QAAQ;EACtC,iBAAiB,kBAAkB,eAAe,SAAS,cAAc,QAAQ;EACjF,OAAO,SAAS,kBAAgB,cAAc;;;UAgB/B;EACf;EACA;EACA;EACA;EACA,OAAO;EACP;EACA;EACA;GACC;;;;;;;cAuCU;;EAMC,YAAA,KAAK;MAIb;EAIJ,OAAO;EAIP,KAAK,kBAAkB,kBAAkB;EAKzC,WAAW;;EA6CL,QAAQ,kBAAkB,kBAAkB,QAAQ;;;;;;;;;;;;;;UCiO3C;;;EAGf;;;;KC1VG,gBAAgB;KAChB,aAAa,OAAO,eAAe,SAAS,4BAA4B;iBAUpE,iBAAiB,qBAAqB;UAIrC;EACR,SAAS;EACT,UAAU;EACV,SAAS;;UAGD;EACR;EACA;EACA;EACA;;EAEA;;EAEA;EACA;EACA,oBAAoB;EACpB,QACE,oBACA,eACA,QAAQ,yBACR,YAAY,uCACZ,SAAS,gBACR;;UAGK;EACR;EACA;EACA;EACA,QAAQ,cAAc,SAAS,0BAA0B;;UAGjD;EACR;EACA,UAAU,YAAY;EACtB,OAAO,YAAY;EAInB,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB;EACA,UAAU,YAAY;EAGtB,kBAAkB;EAClB,OAAO;EACP;EACA,cAAc,IAAI;EAClB,gBAAgB;EAChB;EACA;EACA,UAAU;EACV,YAAY,kBAAkB;EAC9B,QAAQ;EACR,OAAO;EAGP,WAAW,YAAY;EACvB,kBAAkB;EAClB,gBAAgB;EAChB;EACA,WAAW,YAAY;EAGvB;EACA;EACA,eAAe;EACf;EAEA,gBAAgB;IAAkB;IAAmB;;EACrD,gBAAgB;EAGhB,2BAA2B;;;;;;;;EAQ3B,YAAY;;;;;;;EAOZ,gBAAgB;IAAkB;IAAe;;;EAEjD,aAAa;;EAEb,gBAAgB,gBAAgB;;EAEhC,cAAc;;EAEd,mBAAmB,gBAAgB;EACnC;EAIA,cAAc;EAEd,gBAAgB;EAEhB,kBAAkB;EAElB,eAAe;EASf,iBAAiB;EAEjB,wBAAwB,YAAY;EAGpC,oBAAoB;EAEpB,QAAQ;;iBA0DD,WAAW,mBAAmB;EAAQ;EAAc;;iBAcpD,oBAAoB,kBAAkB;iBAuH/B,oBAAoB;EAAoB,QAAQ;EAAe;;iBA8EtE,iBAAiB,SAAS;;;;;;;;;;;;;;;;iBAi0B1B,iBAAiB,MAAM;;;;;;;;;;;;iBAgBjB,eAAe,KAAK,SAAS,kBAAkB,iBAAiB,QAAQ,MAAM;UA8rBnF;EACR,iBAAiB;EACjB,wBAAwB,YAAY;EACpC,oBAAoB;EACpB,WAAW,YAAY;EACvB,eAAe;EACf;EACA;EACA;EACA;EACA,aAAa;EACb,mBAAmB;EAKnB,kBAAkB,kBAAkB;EAGpC,kBAAkB;EAClB;EASA,cAAc;;UAGN;EACR;EACA,YAAY;;EAEZ,UAAU;;EAEV;;;KAqBU,iCAAiC;;;;;;;;;;;;;;;;;;iBAmB7B,yBAAyB,KAAK,SAAS,QAAQ;;;;;;;iBA+ItD,qBAAqB,gBAAgB;;;;;;;;;;;iBAsB/B,qBAAqB,OAAO,eAAe;iBAujCjD,eAAe;iBA+Bf,aAAa,cAAc;iBAsJd,eAAe,KAAK,SAAS,SAAS,iBAAiB;cA6RhE"}

package/dist/runtime.mjs

@@ -1,3 +1,3 @@
 
-import { i as runtimeInternals, n as normalizeToolSchema, r as registerVisionCompanions, t as applyPiPackage } from "./runtime-B_Ig28og.mjs";
+import { i as runtimeInternals, n as normalizeToolSchema, r as registerVisionCompanions, t as applyPiPackage } from "./runtime-B-SlR8mJ.mjs";
 export { applyPiPackage, normalizeToolSchema, registerVisionCompanions, runtimeInternals };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi2dsh",
-  "version": "0.12.3",
+  "version": "0.13.0",
   "description": "Bridge the Pi and DeepSeek Harness ecosystems: a general Pi Host ABI that runs unmodified Pi extensions as native DSH plugins, plus per-package conversion and MCP config translation.",
   "type": "module",
   "bin": {
@@ -52,6 +52,7 @@
     "prepare": "tsdown",
     "test": "pnpm build && vitest run",
     "test:community": "pnpm build && node scripts/verify-community.mjs --generate community/runtime-results.json",
+    "test:codex-image": "pnpm build && node scripts/verify-codex-image-gen-e2e.mjs",
     "test:coverage": "pnpm build && vitest run --coverage",
     "test:dsh": "pnpm build && vitest run tests/dsh-runtime.spec.ts",
     "test:examples": "pnpm build && node scripts/verify-examples-e2e.mjs",