@vellumai/assistant 0.8.7 → 0.8.8

package/src/plugins/types.ts

@@ -7,7 +7,7 @@
  * placeholders) and add the pipeline runner, registry, and bootstrap.
  *
  * The assistant composes behavior around a small set of named pipelines
- * (`turn`, `llmCall`, `toolExecute`, ...). Each plugin may contribute one
+ * (`compaction`, `overflowReduce`, ...). Each plugin may contribute one
  * {@link Middleware} per pipeline; the registry composes them in onion
  * order at runtime. Plugins may also contribute {@link Injector}s that emit
  * system-prompt-time content, as well as model-visible capabilities
@@ -19,6 +19,7 @@
 import type { CompactionCircuitClosedEvent } from "../api/events/compaction-circuit-closed.js";
 import type { CompactionCircuitOpenEvent } from "../api/events/compaction-circuit-open.js";
 import type { ContextWindowConfig } from "../config/schemas/inference.js";
+import type { LLMCallSite } from "../config/schemas/llm.js";
 import type {
   ContextWindowManager,
   ContextWindowResult,
@@ -30,26 +31,13 @@ import type {
   ChannelCommandContext,
   InjectionMode,
 } from "../daemon/conversation-runtime-assembly.js";
-import type { PkbContextConversation } from "../daemon/pkb-context-tracker.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import type { MessageRole } from "../memory/conversation-crud.js";
-import type { QdrantSparseVector } from "../memory/qdrant-client.js";
+import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import type { PluginHookFn } from "../plugin-api/types.js";
-import type {
-  ContentBlock,
-  Message,
-  Provider,
-  ProviderResponse,
-  SendMessageOptions,
-  ToolDefinition,
-} from "../providers/types.js";
+import type { Message } from "../providers/types.js";
 import type { SkillRoute } from "../runtime/skill-route-registry.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
+import type { Tool } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
-import type {
-  ToolResultTruncateArgs,
-  ToolResultTruncateResult,
-} from "./defaults/tool-result-truncate/types.js";
 
 // ─── Manifest ────────────────────────────────────────────────────────────────
 
@@ -120,152 +108,22 @@ export type Middleware<A, R> = (
  * Exhaustive list of pipeline slot names. New pipelines must be added here
  * and in `DEFAULT_TIMEOUTS` (PR 12). The registry only understands these.
  */
-export type PipelineName =
-  | "turn"
-  | "llmCall"
-  | "toolExecute"
-  | "memoryRetrieval"
-  | "tokenEstimate"
-  | "compaction"
-  | "overflowReduce"
-  | "persistence"
-  | "titleGenerate"
-  | "toolResultTruncate"
-  | "emptyResponse"
-  | "toolError"
-  | "circuitBreaker";
+export type PipelineName = "compaction" | "overflowReduce" | "circuitBreaker";
 
 // ─── Per-pipeline args / results (placeholder shapes) ────────────────────────
 // Concrete field-level types land in M2/M3 PRs as each pipeline is wrapped.
 // Until then we expose `unknown`-tagged aliases so downstream code can name
 // the types without depending on unstable internal shapes.
 
-export type TurnArgs = { readonly input: unknown };
-export type TurnResult = { readonly output: unknown };
-
-/**
- * Pipeline arguments for `llmCall` — mirrors the inputs to
- * {@link Provider.sendMessage}. The terminal handler (the default plugin)
- * delegates straight to `args.provider.sendMessage(args.messages, args.options)`;
- * middleware may observe or rewrite any field before that call, short-circuit
- * with a synthetic {@link LLMCallResult}, or post-process the response on the
- * way out.
- *
- * `provider` is passed in `args` (rather than resolved from the runtime) so
- * middleware can swap it deterministically per-call. `options` carries the
- * full `SendMessageOptions` bag — `tools`, `systemPrompt`, `config`,
- * `onEvent`, and `signal` — so middleware can substitute streaming handlers,
- * tool sets, or cancellation signals without reconstructing them.
- */
-export type LLMCallArgs = {
-  readonly provider: Provider;
-  readonly messages: Message[];
-  readonly options?: SendMessageOptions;
-};
-export type LLMCallResult = ProviderResponse;
-
-/**
- * Arguments passed to the `toolExecute` pipeline — mirrors the public
- * {@link ToolExecutor.execute} signature so middleware can observe (and
- * mutate) the tool name, input payload, and the full {@link ToolContext}
- * before the terminal runs the actual execution.
- */
-export interface ToolExecuteArgs {
-  readonly name: string;
-  readonly input: Record<string, unknown>;
-  readonly context: ToolContext;
-}
-
 /**
- * Result returned from the `toolExecute` pipeline — identical to
- * {@link ToolExecutionResult} so short-circuit middleware can supply a
- * synthetic result without invoking the terminal.
+ * Full output of a single memory-graph retrieval — the object returned by
+ * {@link ConversationGraphMemory.prepareMemory} (injected messages, query
+ * vectors, metrics). The agent loop consumes these fields directly to drive
+ * PKB hint search and runtime injection.
  */
-export type ToolExecuteResult = ToolExecutionResult;
-
-/**
- * A single retrieved memory artifact.
- *
- * The memory-graph retriever emits complex, tightly-coupled state (content
- * blocks, query vectors, metrics, events, etc.) that downstream code in the
- * agent loop consumes holistically. Representing each memory-graph output as
- * an opaque `MemoryBlock` lets plugins swap in completely different shapes
- * (custom retrievers, mocks for testing) without requiring the plugin surface
- * to re-declare the graph result schema here. Refined by consumers via
- * runtime narrowing — the default retriever attaches a structural marker so
- * the agent loop can safely unwrap its own output.
- */
-export type MemoryBlock = unknown;
-
-/**
- * Inputs to the memory-retrieval pipeline. The pipeline takes only
- * identifiers and the trust context — the actual data sources (PKB files,
- * NOW.md, memory graph) are side-effectful and read by the terminal.
- *
- * `signal` is the per-turn abort signal forwarded to the memory graph's
- * `prepareMemory` call. Carrying it on `args` (rather than on the
- * `DefaultMemoryRetrievalDeps` extra-state bundle) is load-bearing: the
- * pipeline runner's `linkAbortSignal` swaps any `AbortSignal`-typed
- * property on top-level args for an internal linked signal, so a plugin
- * timeout (or external cancel) actually reaches `prepareMemory` and cancels
- * the underlying retrieval instead of letting it run to completion after
- * the pipeline has already errored.
- */
-export interface MemoryArgs {
-  readonly conversationId: string;
-  readonly trustContext: TrustContext | undefined;
-  readonly turnIndex: number;
-  readonly signal: AbortSignal;
-}
-
-/**
- * Outputs of the memory-retrieval pipeline.
- *
- * - `pkbContent` / `nowContent`: trimmed file contents ready for injection,
- *   or `null` when the file is missing/empty.
- * - `memoryGraphBlocks`: zero or one memory-graph retrievals (the default
- *   retriever yields exactly one when the actor is trusted and the graph
- *   produced output, zero otherwise). Multi-entry arrays are reserved for
- *   future multi-source retrievers; the current agent loop consumes only
- *   the first entry.
- */
-export interface MemoryResult {
-  readonly pkbContent: string | null;
-  readonly nowContent: string | null;
-  readonly memoryGraphBlocks: ReadonlyArray<MemoryBlock>;
-}
-
-/**
- * Inputs to the `tokenEstimate` pipeline. The default middleware delegates
- * these straight to {@link estimatePromptTokensRaw}; custom plugins may
- * substitute an alternate estimator (e.g. provider-native tokenization) by
- * short-circuiting the pipeline with their own {@link EstimateResult}.
- *
- * Fields:
- * - `history` — current message list to estimate over.
- * - `systemPrompt` — system prompt string, or `undefined` when absent.
- * - `tools` — tool definitions visible on this turn. The default plugin
- *   sums their token budget via `estimateToolsTokens(tools)` and hands the
- *   result to the raw estimator via `toolTokenBudget`. Plugins that want to
- *   ignore tool cost can skip that term.
- * - `providerName` — canonical calibration provider key (the value returned
- *   by `getCalibrationProviderKey(provider)`). Drives provider-specific
- *   heuristics inside the raw estimator (e.g. Anthropic image sizing).
- */
-export type EstimateArgs = {
-  readonly history: Message[];
-  readonly systemPrompt: string | undefined;
-  readonly tools: ToolDefinition[];
-  readonly providerName: string | undefined;
-};
-
-/** Result of the `tokenEstimate` pipeline — total estimated prompt tokens. */
-export type EstimateResult = number;
-
-/** Alias retained for symmetry with the rest of the pipeline-name family. */
-export type TokenEstimateArgs = EstimateArgs;
-/** Alias retained for symmetry with the rest of the pipeline-name family. */
-export type TokenEstimateResult = EstimateResult;
+export type GraphMemoryResult = Awaited<
+  ReturnType<ConversationGraphMemory["prepareMemory"]>
+>;
 
 /**
  * Pipeline inputs for the `compaction` slot — the arguments the assistant
@@ -409,270 +267,6 @@ export interface OverflowReduceResult {
   readonly attempts: number;
 }
 
-/**
- * Pipeline arguments for `persistence` — a discriminated union over the
- * message-CRUD operations plugins may observe, redirect, or short-circuit:
- *
- * - `add`           — append a new message (`addMessage`). Mirrors
- *                     `addMessage(conversationId, role, content, options?)`.
- *                     When `syncToDisk` is set, the default plugin also runs
- *                     {@link syncMessageToDisk} against the just-persisted row
- *                     so the JSONL disk view stays consistent. The
- *                     `createdAtMs` field carries the conversation's creation
- *                     timestamp — needed to resolve the disk-view directory.
- * - `reserve`       — pre-allocate an empty assistant anchor row
- *                     (`reserveMessage`) so the agent loop can stamp streaming
- *                     events with stable identity before any content is
- *                     produced. Returns the same row shape as `add`.
- * - `updateContent` — overwrite the content of an existing message
- *                     (`updateMessageContent`). Used to finalize a previously
- *                     reserved row, and by consolidation paths.
- * - `update`        — shallow-merge metadata into an existing message
- *                     (`updateMessageMetadata`). Returns `void`.
- * - `delete`        — remove a single message (`deleteMessageById`). Returns
- *                     the {@link DeletedMemoryIds}-shaped segment/summary IDs
- *                     the caller must clean up out-of-band.
- *
- * The discriminated `op` field lets plugin middleware narrow the union and
- * tailor behavior per-operation (e.g. "only observe deletes", "redirect
- * adds to a mock store").
- */
-export type PersistAddArgs = {
-  readonly op: "add";
-  readonly conversationId: string;
-  readonly role: MessageRole;
-  readonly content: string;
-  readonly metadata?: Record<string, unknown>;
-  readonly addOptions?: { readonly skipIndexing?: boolean };
-  /**
-   * When `true`, the default plugin additionally invokes
-   * {@link syncMessageToDisk} with the returned message's id. Requires
-   * {@link createdAtMs} to resolve the conversation's disk-view directory.
-   */
-  readonly syncToDisk?: boolean;
-  /** Conversation creation timestamp — only read when `syncToDisk` is true. */
-  readonly createdAtMs?: number;
-};
-
-export type PersistReserveArgs = {
-  readonly op: "reserve";
-  readonly conversationId: string;
-  readonly role: MessageRole;
-  readonly metadata?: Record<string, unknown>;
-};
-
-export type PersistUpdateContentArgs = {
-  readonly op: "updateContent";
-  readonly messageId: string;
-  readonly content: string;
-};
-
-export type PersistUpdateArgs = {
-  readonly op: "update";
-  readonly messageId: string;
-  readonly updates: Record<string, unknown>;
-};
-
-export type PersistDeleteArgs = {
-  readonly op: "delete";
-  readonly messageId: string;
-};
-
-export type PersistArgs =
-  | PersistAddArgs
-  | PersistReserveArgs
-  | PersistUpdateContentArgs
-  | PersistUpdateArgs
-  | PersistDeleteArgs;
-
-/**
- * Result row returned by an `add` op — matches the shape produced by
- * {@link addMessage}. Kept structural (not imported from `memory/`) so the
- * plugin types module stays decoupled from the storage layer.
- */
-export type PersistAddResult = {
-  readonly op: "add";
-  readonly message: {
-    readonly id: string;
-    readonly conversationId: string;
-    readonly role: string;
-    readonly content: string;
-    readonly createdAt: number;
-    readonly metadata?: string;
-  };
-};
-
-/**
- * Result row returned by a `reserve` op — same row shape as `add` but with
- * empty `content` (`"[]"`) and tagged distinctly so middleware can branch
- * on intent.
- */
-export type PersistReserveResult = {
-  readonly op: "reserve";
-  readonly message: {
-    readonly id: string;
-    readonly conversationId: string;
-    readonly role: string;
-    readonly content: string;
-    readonly createdAt: number;
-    readonly metadata?: string;
-  };
-};
-
-export type PersistUpdateContentResult = { readonly op: "updateContent" };
-
-export type PersistUpdateResult = { readonly op: "update" };
-
-/** IDs of segments/summaries the caller must remove from Qdrant. */
-export type PersistDeleteResult = {
-  readonly op: "delete";
-  readonly segmentIds: string[];
-  readonly deletedSummaryIds: string[];
-};
-
-export type PersistResult =
-  | PersistAddResult
-  | PersistReserveResult
-  | PersistUpdateContentResult
-  | PersistUpdateResult
-  | PersistDeleteResult;
-
-/**
- * Arguments for the `titleGenerate` pipeline. Mirrors the parameters of
- * `queueGenerateConversationTitle` in `memory/conversation-title-service.ts`
- * so the default plugin can delegate verbatim.
- *
- * `provider` is optional because the underlying service falls back to
- * `getConfiguredProvider("conversationTitle")` when absent. `userMessage`
- * carries the first turn's text — the service uses it as LLM context and
- * also to derive a deterministic fallback title if the call fails.
- *
- * `onTitleUpdated` is a fire-and-forget callback the pipeline invokes when
- * the title is finally persisted. The default implementation is
- * fire-and-forget overall, so the pipeline result (`TitleResult`) carries no
- * payload — callers that need the title must use the callback.
- */
-export type TitleArgs = {
-  readonly conversationId: string;
-  readonly provider?: Provider;
-  readonly userMessage: string;
-  readonly onTitleUpdated?: (title: string) => void;
-};
-/**
- * Result of the `titleGenerate` pipeline. The default implementation is
- * fire-and-forget (it schedules background work and returns immediately),
- * so there is nothing meaningful to return. Defined as an empty object so
- * custom plugins can opt into richer payloads later.
- */
-export type TitleResult = Readonly<Record<string, never>>;
-
-/**
- * @deprecated Alias kept for the M1 scaffolding era. Prefer {@link TitleArgs}.
- */
-export type TitleGenerateArgs = TitleArgs;
-/**
- * @deprecated Alias kept for the M1 scaffolding era. Prefer {@link TitleResult}.
- */
-export type TitleGenerateResult = TitleResult;
-
-/**
- * Snapshot of the just-completed assistant turn plus retry/context counters
- * the `emptyResponse` pipeline needs to decide whether to nudge, accept, or
- * surface an error.
- *
- * `emptyResponseRetries` is the *current* retry counter — the pipeline may
- * compare it to `maxEmptyResponseRetries` to implement a retry cap. The loop
- * increments the counter only after a `"nudge"` decision; the pipeline is
- * stateless across turns.
- *
- * `priorAssistantHadVisibleText` signals that an earlier turn in the current
- * `run()` invocation already delivered user-visible text. When true, an
- * empty follow-up is the model correctly ending its turn and nudging would
- * mislead it into resending text the user already saw.
- */
-export interface EmptyResponseArgs {
-  /** Content blocks produced by the assistant on this turn. */
-  readonly responseContent: ReadonlyArray<ContentBlock>;
-  /**
-   * Number of `tool_use` blocks in `responseContent`. Mirrors the loop's own
-   * count so middleware doesn't have to recompute it. When > 0 the turn is
-   * not empty — the model issued tool calls.
-   */
-  readonly toolUseBlocksLength: number;
-  /** 0-based index of the tool-use turn being evaluated. */
-  readonly toolUseTurns: number;
-  /** How many empty-response nudges the loop has already issued this run. */
-  readonly emptyResponseRetries: number;
-  /** Upper bound for `emptyResponseRetries`. The default is 1. */
-  readonly maxEmptyResponseRetries: number;
-  /**
-   * Whether ANY prior assistant turn in the current `run()` call carried
-   * visible text. See `agent/loop.ts` for why the whole-run scan matters.
-   */
-  readonly priorAssistantHadVisibleText: boolean;
-  /**
-   * Provider-reported stop reason for the assistant turn being evaluated.
-   * `null`/`undefined` when the provider didn't report one (older
-   * providers, partial responses). The default terminal uses this to
-   * distinguish an explicit safety-classifier refusal (Anthropic's
-   * `"refusal"`) from an organically-empty turn — refusals deserve a
-   * nudge even on the very first model call of the run, whereas an
-   * organically-empty first call usually means the model legitimately
-   * had nothing to say.
-   */
-  readonly stopReason: string | null | undefined;
-}
-
-/**
- * Decision produced by the `emptyResponse` pipeline.
- *
- * - `"nudge"`  — loop appends `nudgeText` as a `user` message and retries.
- *                `nudgeText` MUST be present; it is what the model will see.
- * - `"accept"` — loop treats the turn as complete (pushes the assistant
- *                message to history and exits the tool-use chain normally).
- * - `"error"`  — loop surfaces a clear error. Reserved for middleware that
- *                wants to escalate an empty response rather than absorb it.
- */
-export interface EmptyResponseDecision {
-  readonly action: "nudge" | "accept" | "error";
-  /** Nudge text the loop will push to history. Required when `action === "nudge"`. */
-  readonly nudgeText?: string;
-}
-
-/** Alias so the {@link PipelineMiddlewareMap} entry names its own result shape. */
-export type EmptyResponseResult = EmptyResponseDecision;
-
-/**
- * Arguments to the `toolError` pipeline — invoked by the agent loop once per
- * turn that produced tool results, BEFORE the turn's tool-result user message
- * is pushed into history.
- *
- * `hasToolError` is true when at least one tool in the current turn returned
- * `isError: true`. `consecutiveErrorTurns` is the running count of
- * back-to-back error turns (reset to 0 on a clean turn, incremented on each
- * error turn). `maxConsecutiveErrorNudges` is the default cap the agent loop
- * currently applies; plugins receive it so they can match the default
- * threshold exactly or compute a relative offset.
- */
-export type ToolErrorArgs = {
-  readonly hasToolError: boolean;
-  readonly consecutiveErrorTurns: number;
-  readonly maxConsecutiveErrorNudges: number;
-};
-
-/**
- * Decision returned by the `toolError` pipeline. When `action` is `"nudge"`,
- * the agent loop appends a text block with `nudgeText` to the turn's tool
- * results so the next LLM turn sees the nudge. When `action` is `"skip"`, no
- * nudge is injected and the tool results pass through unchanged.
- */
-export type ToolErrorDecision =
-  | { readonly action: "nudge"; readonly nudgeText: string }
-  | { readonly action: "skip" };
-
-/** Alias kept so `PipelineMiddlewareMap.toolError` reads result-shaped. */
-export type ToolErrorResult = ToolErrorDecision;
-
 /**
  * Arguments for the `circuitBreaker` pipeline.
  *
@@ -741,21 +335,8 @@ export type CircuitBreakerResult = {
  * `getMiddlewaresFor<P>()` type narrowing in PR 13.
  */
 export interface PipelineMiddlewareMap {
-  turn: Middleware<TurnArgs, TurnResult>;
-  llmCall: Middleware<LLMCallArgs, LLMCallResult>;
-  toolExecute: Middleware<ToolExecuteArgs, ToolExecuteResult>;
-  memoryRetrieval: Middleware<MemoryArgs, MemoryResult>;
-  tokenEstimate: Middleware<TokenEstimateArgs, TokenEstimateResult>;
   compaction: Middleware<CompactionArgs, CompactionResult>;
   overflowReduce: Middleware<OverflowReduceArgs, OverflowReduceResult>;
-  persistence: Middleware<PersistArgs, PersistResult>;
-  titleGenerate: Middleware<TitleArgs, TitleResult>;
-  toolResultTruncate: Middleware<
-    ToolResultTruncateArgs,
-    ToolResultTruncateResult
-  >;
-  emptyResponse: Middleware<EmptyResponseArgs, EmptyResponseResult>;
-  toolError: Middleware<ToolErrorArgs, ToolErrorResult>;
   circuitBreaker: Middleware<CircuitBreakerArgs, CircuitBreakerResult>;
 }
 
@@ -790,43 +371,6 @@ export interface TurnInjectionInputs {
   readonly workspaceTopLevelContext?: string | null;
   /** Pre-built unified-turn-context text (`<turn_context>...`) or null to skip. */
   readonly unifiedTurnContext?: string | null;
-  /** PKB auto-injected content (`<knowledge_base>...`) or null to skip. */
-  readonly pkbContext?: string | null;
-  /**
-   * Whether PKB is active for this turn — drives the `<system_reminder>` /
-   * hybrid-search relevance-hint branch.
-   */
-  readonly pkbActive?: boolean;
-  /** Dense query vector surfaced from the graph memory retriever for PKB hints. */
-  readonly pkbQueryVector?: number[];
-  /** Optional sparse vector accompanying `pkbQueryVector`. */
-  readonly pkbSparseVector?: QdrantSparseVector;
-  /** Memory scope id used to filter PKB search results. */
-  readonly pkbScopeId?: string;
-  /**
-   * Live conversation (or a minimal shape containing `messages`) used to
-   * compute which PKB paths are already "in context" and therefore suppressed
-   * from hint suggestions.
-   */
-  readonly pkbConversation?: PkbContextConversation;
-  /** Auto-injected PKB filenames resolved relative to `pkbRoot`. */
-  readonly pkbAutoInjectList?: string[];
-  /** Absolute path to the PKB directory (e.g. `<workspace>/pkb`). */
-  readonly pkbRoot?: string;
-  /**
-   * Working directory against which relative `file_read` paths resolve.
-   * Falls back to `pkbRoot` when omitted.
-   */
-  readonly pkbWorkingDir?: string;
-  /**
-   * Pre-rendered v2 static memory content (essentials/threads/recent/buffer
-   * concatenated, header-wrapped) or null to skip. The agent loop only
-   * passes this on full-mode turns; the injector wraps it in `<memory>` for
-   * the user message.
-   */
-  readonly memoryV2Static?: string | null;
-  /** NOW.md scratchpad content or null to skip. */
-  readonly nowScratchpad?: string | null;
   /** Pre-built `<active_subagents>` block or null to skip. */
   readonly subagentStatusBlock?: string | null;
   /** Channel capabilities — drives slack gating. */
@@ -937,6 +481,20 @@ export interface TurnContext {
    * a context without `injectionInputs` produces an empty injection chain.
    */
   injectionInputs?: TurnInjectionInputs;
+  /**
+   * The {@link LLMCallSite} this turn's pipeline work belongs to —
+   * `"mainAgent"` for the user-facing conversational reply, or the specific
+   * background/utility site (`"compactionAgent"`, `"subagentSpawn"`,
+   * `"memoryConsolidation"`, `"conversationTitle"`, …) when the agent loop is
+   * driving non-main work that happens to share the same `conversationId`.
+   *
+   * Lets {@link Injector}s and pipeline middleware scope their behaviour to
+   * the main reply and stay out of background turns, which `onEvent` presence
+   * alone cannot distinguish (compaction and subagent loops also stream).
+   * Omitted by call sites that don't tag a site (synthesized test contexts);
+   * consumers should treat absence conservatively.
+   */
+  callSite?: LLMCallSite;
 }
 
 // ─── Injectors ───────────────────────────────────────────────────────────────
@@ -1016,8 +574,21 @@ export interface Injector {
   name: string;
   /** Ascending sort key — lower runs first. */
   order: number;
-  /** Produce a block, or `null` to contribute nothing on this turn. */
-  produce(ctx: TurnContext): Promise<InjectionBlock | null>;
+  /**
+   * Produce a block, or `null` to contribute nothing on this turn.
+   *
+   * `runMessages` is the turn's working message array — the same array the
+   * chain's blocks are spliced onto — passed explicitly so injectors that
+   * need the current prompt contents (e.g. the PKB reminder, which scans for
+   * already-loaded `file_read` paths) read it from a parameter rather than a
+   * field on the shared {@link TurnContext}. Absent for text-only chain
+   * consumers ({@link composeInjectorChain}) that drive injectors without a
+   * message array.
+   */
+  produce(
+    ctx: TurnContext,
+    runMessages?: Message[],
+  ): Promise<InjectionBlock | null>;
 }
 
 // ─── Model-visible capability slots ──────────────────────────────────────────
@@ -1104,7 +675,7 @@ export type PluginHooks = Record<string, PluginHookFn<any>>;
 
 /**
  * A registered plugin. Every field besides `manifest` is optional — a plugin
- * may contribute any combination of middleware, injectors, and model-visible
+ * may contribute any combination of middleware and model-visible
  * capabilities. Lifecycle hooks live under `hooks`.
  */
 export interface Plugin {
@@ -1126,8 +697,6 @@ export interface Plugin {
   routes?: PluginRouteRegistration[];
   /** Skill registrations loaded at startup. */
   skills?: PluginSkillRegistration[];
-  /** Prompt-time injectors contributed by this plugin. */
-  injectors?: Injector[];
   /**
    * Named middleware slots. At most one middleware per slot per plugin.
    * The registry composes multiple plugins' middleware for a slot in

package/src/proactive-artifact/aux-message-injector.ts

@@ -24,7 +24,7 @@ async function waitForIdle(conversationId: string): Promise<boolean> {
   const start = Date.now();
   while (Date.now() - start < IDLE_TIMEOUT_MS) {
     const conv = findConversation(conversationId);
-    if (!conv || !conv.processing) return true;
+    if (!conv || !conv.isProcessing()) return true;
     await new Promise((resolve) => setTimeout(resolve, IDLE_POLL_MS));
   }
   return false;
@@ -36,7 +36,7 @@ export async function injectAuxAssistantMessage(params: {
   broadcastMessage: BroadcastFn;
 }): Promise<void> {
   const conv = findConversation(params.conversationId);
-  if (conv?.processing) {
+  if (conv?.isProcessing()) {
     const reachedIdle = await waitForIdle(params.conversationId);
     if (!reachedIdle) {
       log.warn(
@@ -54,7 +54,7 @@ export async function injectAuxAssistantMessage(params: {
   );
 
   const current = findConversation(params.conversationId);
-  if (current && !current.processing) {
+  if (current && !current.isProcessing()) {
     current.getMessages().push(createAssistantMessage(params.text));
 
     params.broadcastMessage({