@sentry/junior 0.90.0 → 0.92.0

package/dist/chat/state/session-log.d.ts

@@ -1,6 +1,32 @@
 import { z } from "zod";
+import { type Actor } from "@sentry/junior-plugin-api";
 import { type PiMessage } from "@/chat/pi/messages";
-import { type StoredSlackRequester } from "@/chat/requester";
+import { type StoredSlackActor } from "@/chat/actor";
+declare const piMessageAuthoritySchema: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+declare const piMessageProvenanceSchema: z.ZodObject<{
+    authority: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+    actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        platform: z.ZodLiteral<"slack">;
+        teamId: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"local">;
+        email: z.ZodOptional<z.ZodString>;
+        fullName: z.ZodOptional<z.ZodString>;
+        userId: z.ZodString;
+        userName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        platform: z.ZodLiteral<"system">;
+        name: z.ZodString;
+    }, z.core.$strict>], "platform">>;
+}, z.core.$strict>;
+/** Whether a user-role Pi message is a durable instruction or ambient context. */
+export type PiMessageAuthority = z.output<typeof piMessageAuthoritySchema>;
+/** Per-message record of the actor a Pi message came from and its authority weight. */
+export type PiMessageProvenance = z.output<typeof piMessageProvenanceSchema>;
 declare const authorizationKindSchema: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
 declare const transcriptRefSchema: z.ZodObject<{
     type: z.ZodLiteral<"advisor_session">;
@@ -8,16 +34,36 @@ declare const transcriptRefSchema: z.ZodObject<{
     key: z.ZodString;
 }, z.core.$strip>;
 declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"pi_message">;
     sessionId: z.ZodDefault<z.ZodString>;
     message: z.ZodPipe<z.ZodObject<{
         role: z.ZodString;
-    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
         [x: string]: unknown;
         role: string;
     }>>;
-    requester: z.ZodOptional<z.ZodObject<{
+    provenance: z.ZodOptional<z.ZodObject<{
+        authority: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+        actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            platform: z.ZodLiteral<"slack">;
+            teamId: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"local">;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
+        }, z.core.$strict>], "platform">>;
+    }, z.core.$strict>>;
+    actor: z.ZodOptional<z.ZodObject<{
         email: z.ZodOptional<z.ZodString>;
         fullName: z.ZodOptional<z.ZodString>;
         platform: z.ZodOptional<z.ZodLiteral<"slack">>;
@@ -26,16 +72,36 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         teamId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"projection_reset">;
     sessionId: z.ZodDefault<z.ZodString>;
     messages: z.ZodArray<z.ZodPipe<z.ZodObject<{
         role: z.ZodString;
-    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
+    }, z.core.$loose>, z.ZodTransform<import("@earendil-works/pi-ai").AssistantMessage | import("@earendil-works/pi-ai").UserMessage | import("@earendil-works/pi-ai").ToolResultMessage<any> | import("@earendil-works/pi-agent-core").CustomMessage<unknown> | import("@earendil-works/pi-agent-core").BashExecutionMessage | import("@earendil-works/pi-agent-core").BranchSummaryMessage | import("@earendil-works/pi-agent-core").CompactionSummaryMessage, {
         [x: string]: unknown;
         role: string;
     }>>>;
-    requester: z.ZodOptional<z.ZodObject<{
+    provenance: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        authority: z.ZodUnion<readonly [z.ZodLiteral<"instruction">, z.ZodLiteral<"context">]>;
+        actor: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            platform: z.ZodLiteral<"slack">;
+            teamId: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"local">;
+            email: z.ZodOptional<z.ZodString>;
+            fullName: z.ZodOptional<z.ZodString>;
+            userId: z.ZodString;
+            userName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            platform: z.ZodLiteral<"system">;
+            name: z.ZodString;
+        }, z.core.$strict>], "platform">>;
+    }, z.core.$strict>>>;
+    actor: z.ZodOptional<z.ZodObject<{
         email: z.ZodOptional<z.ZodString>;
         fullName: z.ZodOptional<z.ZodString>;
         platform: z.ZodOptional<z.ZodLiteral<"slack">>;
@@ -44,10 +110,10 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         teamId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
-    type: z.ZodLiteral<"requester_recorded">;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
+    type: z.ZodLiteral<"actor_recorded">;
     sessionId: z.ZodDefault<z.ZodString>;
-    requester: z.ZodObject<{
+    actor: z.ZodObject<{
         email: z.ZodOptional<z.ZodString>;
         fullName: z.ZodOptional<z.ZodString>;
         platform: z.ZodOptional<z.ZodLiteral<"slack">>;
@@ -56,31 +122,31 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         teamId: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"mcp_provider_connected">;
     sessionId: z.ZodDefault<z.ZodString>;
     provider: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"authorization_requested">;
     sessionId: z.ZodDefault<z.ZodString>;
     createdAtMs: z.ZodNumber;
     kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
     provider: z.ZodString;
-    requesterId: z.ZodString;
+    actorId: z.ZodString;
     authorizationId: z.ZodString;
     delivery: z.ZodUnion<readonly [z.ZodLiteral<"private_link_sent">, z.ZodLiteral<"private_link_reused">]>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"authorization_completed">;
     sessionId: z.ZodDefault<z.ZodString>;
     createdAtMs: z.ZodNumber;
     kind: z.ZodUnion<readonly [z.ZodLiteral<"plugin">, z.ZodLiteral<"mcp">]>;
     provider: z.ZodString;
-    requesterId: z.ZodString;
+    actorId: z.ZodString;
     authorizationId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"tool_execution_started">;
     sessionId: z.ZodDefault<z.ZodString>;
     createdAtMs: z.ZodNumber;
@@ -88,7 +154,7 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     toolName: z.ZodString;
     args: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"subagent_started">;
     sessionId: z.ZodDefault<z.ZodString>;
     subagentInvocationId: z.ZodString;
@@ -104,7 +170,7 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     historyMode: z.ZodLiteral<"shared">;
     createdAtMs: z.ZodNumber;
 }, z.core.$strip>, z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
+    schemaVersion: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>;
     type: z.ZodLiteral<"subagent_ended">;
     sessionId: z.ZodDefault<z.ZodString>;
     subagentInvocationId: z.ZodString;
@@ -114,7 +180,7 @@ declare const sessionLogEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     transcriptStartMessageIndex: z.ZodOptional<z.ZodNumber>;
     createdAtMs: z.ZodNumber;
 }, z.core.$strip>], "type">;
-/** Requester identity stored with turn-start messages for durable continuation. */
+/** Actor identity stored with turn-start messages for durable continuation. */
 export type SessionLogEntry = z.infer<typeof sessionLogEntrySchema>;
 export type AuthorizationKind = z.infer<typeof authorizationKindSchema>;
 export type TranscriptRef = z.infer<typeof transcriptRefSchema>;
@@ -137,10 +203,21 @@ export interface SessionLogStore {
     append(args: AppendArgs): Promise<void>;
     read(scope: Scope): Promise<SessionLogEntry[]>;
 }
+/** Aligned Pi-message projection: `provenance[i]` describes `messages[i]`. */
 export interface SessionProjection {
     messages: PiMessage[];
-    requester?: StoredSlackRequester;
+    provenance: PiMessageProvenance[];
 }
+/**
+ * All distinct actors annotated on instruction-authority messages, in
+ * first-seen order — the run's actors. This is attribution, never
+ * authority: it exists so provenance consumers know which actors
+ * contributed instructions to a run. It must never feed credential
+ * issuance, credential-subject selection, or scope ownership.
+ * Unattributable instructions (no resolvable actor) never join;
+ * distinctness is by identity ids only, never display fields.
+ */
+export declare function instructionActors(provenance: PiMessageProvenance[]): Actor[];
 /** Load chronological host-only runtime activity entries for reporting. */
 export declare function loadActivityEntries(args: Scope & {
     store?: SessionLogStore;
@@ -152,19 +229,38 @@ export declare function loadMessages(args: Scope & {
     messageCount: number;
     sessionId?: string;
 }): Promise<PiMessage[] | undefined>;
+/** Load the committed Pi-message projection with aligned per-message provenance. */
+export declare function loadMessagesWithProvenance(args: Scope & {
+    store?: SessionLogStore;
+    messageCount: number;
+    sessionId?: string;
+}): Promise<SessionProjection | undefined>;
 /** Load the full current Pi-message projection for a conversation. */
 export declare function loadProjection(args: Scope & {
     store?: SessionLogStore;
     sessionId?: string;
 }): Promise<PiMessage[]>;
 /**
- * Load the Pi-message projection and derived requester identity in one read.
- * Used at continuation boundaries to avoid a second log scan.
+ * Load the Pi-message projection with aligned per-message provenance in one
+ * read. Used at continuation boundaries to avoid a second log scan.
  */
-export declare function loadProjectionWithRequester(args: Scope & {
+export declare function loadProjectionWithProvenance(args: Scope & {
     store?: SessionLogStore;
     sessionId?: string;
 }): Promise<SessionProjection>;
+/**
+ * Load the projection with the latest instruction actor as a stored Slack
+ * actor. Retained for callers that still key on a single latest actor; it
+ * derives the actor from per-message provenance rather than a latest-wins
+ * field.
+ */
+export declare function loadProjectionWithActor(args: Scope & {
+    store?: SessionLogStore;
+    sessionId?: string;
+}): Promise<{
+    messages: PiMessage[];
+    actor?: StoredSlackActor;
+}>;
 /** Load MCP providers that were durably connected in this conversation. */
 export declare function loadConnectedMcpProviders(args: Scope & {
     store?: SessionLogStore;
@@ -180,7 +276,7 @@ export declare function recordAuthorizationRequested(args: Scope & {
     store?: SessionLogStore;
     kind: AuthorizationKind;
     provider: string;
-    requesterId: string;
+    actorId: string;
     authorizationId: string;
     delivery: "private_link_sent" | "private_link_reused";
     ttlMs: number;
@@ -190,7 +286,7 @@ export declare function recordAuthorizationCompleted(args: Scope & {
     store?: SessionLogStore;
     kind: AuthorizationKind;
     provider: string;
-    requesterId: string;
+    actorId: string;
     authorizationId: string;
     ttlMs: number;
 }): Promise<void>;
@@ -241,8 +337,26 @@ export declare function commitMessages(args: Scope & {
     store?: SessionLogStore;
     messages: PiMessage[];
     ttlMs: number;
-    requester?: StoredSlackRequester;
+    /** Explicit per-message provenance aligned one-to-one with `messages`. */
+    provenance?: PiMessageProvenance[];
+    /** Explicit provenance for the trailing newly committed messages. */
+    trailingMessageProvenance?: PiMessageProvenance[];
+    /** Default applied to the last new user message when no explicit array. */
+    newMessageProvenance?: PiMessageProvenance;
 }): Promise<{
     sessionId: string;
+    provenance: PiMessageProvenance[];
 }>;
+/** Build an instruction-provenance record for the given actor. */
+export declare function instructionProvenanceFor(actor: Actor | undefined): PiMessageProvenance;
+/** Unattributed ambient-context provenance for non-instruction Pi messages. */
+export declare const contextProvenance: PiMessageProvenance;
+/**
+ * Parse durably-stored message provenance, failing closed on misalignment.
+ *
+ * A missing field is a legacy record: it materializes as unauthored context of
+ * the expected length. A present-but-malformed or wrong-length value returns
+ * undefined so callers reject the record rather than zip a mismatched array.
+ */
+export declare function parseStoredMessageProvenance(value: unknown, expectedLength: number): PiMessageProvenance[] | undefined;
 export {};

package/dist/chat/state/turn-session.d.ts

@@ -1,6 +1,7 @@
 import { type Destination, type Source } from "@sentry/junior-plugin-api";
 import type { PiMessage } from "@/chat/pi/messages";
-import { type Requester } from "@/chat/requester";
+import { type Actor } from "@/chat/actor";
+import { type PiMessageProvenance } from "./session-log";
 import type { AgentTurnUsage } from "@/chat/usage";
 import type { ConversationPrivacy } from "@/chat/conversation-privacy";
 import type { ConversationStore } from "@/chat/conversations/store";
@@ -19,7 +20,17 @@ export interface AgentTurnSessionRecord {
     lastProgressAtMs: number;
     loadedSkillNames?: string[];
     piMessages: PiMessage[];
-    requester?: Requester;
+    /** Per-message provenance aligned one-to-one with `piMessages`. */
+    piMessageProvenance: PiMessageProvenance[];
+    /**
+     * All distinct actors annotated on this run's committed instruction-authority
+     * messages, in first-seen order. Derived from `piMessageProvenance` at
+     * materialization — never persisted separately, so it cannot drift from
+     * provenance. Attribution only; never an authority source.
+     */
+    actors: Actor[];
+    /** The single actor this run executes as (credential binding, auth flows). */
+    actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
     resumedFromSliceId?: number;
     sessionId: string;
@@ -31,7 +42,7 @@ export interface AgentTurnSessionRecord {
     turnStartMessageIndex?: number;
     updatedAtMs: number;
 }
-export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "piMessages" | "turnStartMessageIndex">;
+export type AgentTurnSessionSummary = Omit<AgentTurnSessionRecord, "errorMessage" | "actors" | "piMessages" | "piMessageProvenance" | "turnStartMessageIndex">;
 /** Read a materialized turn session record for resume and history loading. */
 export declare function getAgentTurnSessionRecord(conversationId: string, sessionId: string): Promise<AgentTurnSessionRecord | undefined>;
 /** Commit stable Pi session state and advance the turn session record. */
@@ -52,7 +63,9 @@ export declare function upsertAgentTurnSessionRecord(args: {
     state: AgentTurnSessionStatus;
     surface?: AgentTurnSurface;
     piMessages: PiMessage[];
-    requester?: Requester;
+    /** Provenance for trailing newly committed messages, such as steering. */
+    trailingMessageProvenance?: PiMessageProvenance[];
+    actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
     errorMessage?: string;
     resumedFromSliceId?: number;
@@ -77,7 +90,7 @@ export declare function recordAgentTurnSessionSummary(args: {
     lastProgressAtMs?: number;
     loadedSkillNames?: string[];
     conversationStore?: ConversationStore;
-    requester?: Requester;
+    actor?: Actor;
     resumeReason?: AgentTurnResumeReason;
     sessionId: string;
     sliceId: number;

package/dist/chat/task-execution/slack-work.d.ts

@@ -5,7 +5,7 @@ import type { ConversationStore } from "@/chat/conversations/store";
 import type { InboundMessage } from "@/chat/task-execution/store";
 import type { ConversationWorkerContext, ConversationWorkerResult } from "@/chat/task-execution/worker";
 import { type SlackInstallationContext } from "@/chat/slack/adapter-context";
-import { type SlackRequesterProfile } from "@/chat/requester";
+import { type SlackActorProfile } from "@/chat/actor";
 export type SlackConversationRoute = "mention" | "subscribed";
 export interface SlackConversationMessageMetadata {
     [key: string]: unknown;
@@ -44,7 +44,7 @@ interface SlackResourceEventInboundInput {
 }
 export interface CreateSlackConversationWorkerOptions {
     getSlackAdapter: () => SlackAdapter;
-    lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackRequesterProfile | null | undefined>;
+    lookupSlackUser?: (teamId: string, userId: string) => Promise<SlackActorProfile | null | undefined>;
     resumeAwaitingContinuation: (conversationId: string) => Promise<boolean>;
     conversationStore?: ConversationStore;
     runtime: SlackInboxTurnRuntime;

package/dist/chat/task-execution/state.d.ts

@@ -1,6 +1,6 @@
 import type { StateAdapter } from "chat";
 import type { Destination } from "@sentry/junior-plugin-api";
-import { type StoredSlackRequester } from "@/chat/requester";
+import { type StoredSlackActor } from "@/chat/actor";
 declare class InvalidConversationRecordError extends Error {
     constructor(conversationId: string);
 }
@@ -55,7 +55,7 @@ export interface Conversation {
     destination?: Destination;
     execution: ConversationExecution;
     lastActivityAtMs: number;
-    requester?: StoredSlackRequester;
+    actor?: StoredSlackActor;
     schemaVersion: 1;
     source?: Source;
     title?: string;
@@ -131,7 +131,7 @@ export declare function recordConversationActivity(args: {
     conversationId: string;
     destination?: Destination;
     nowMs?: number;
-    requester?: StoredSlackRequester;
+    actor?: StoredSlackActor;
     source?: Source;
     state?: StateAdapter;
     title?: string;
@@ -150,7 +150,7 @@ export declare function recordConversationExecution(args: {
         updatedAtMs?: number;
     };
     lastActivityAtMs: number;
-    requester?: StoredSlackRequester;
+    actor?: StoredSlackActor;
     source?: Source;
     state?: StateAdapter;
     title?: string;

package/dist/chat/tool-support/zod-tool.d.ts

@@ -1,13 +1,13 @@
 import { z, type ZodType, type ZodTypeAny } from "zod";
 import { type JuniorToolResult } from "@/chat/tool-support/structured-result";
 import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
-import type { AnyToolDefinition, ToolExecuteOptions } from "@/chat/tools/definition";
+import type { AnyToolDefinition, JsonSchemaObject, ToolExecuteOptions } from "@/chat/tools/definition";
 type ZodToolDefinitionBase<TInputSchema extends ZodTypeAny> = Pick<AnyToolDefinition, "identity" | "description" | "exposure" | "annotations" | "promptSnippet" | "promptGuidelines" | "executionMode"> & {
     inputSchema: TInputSchema;
     prepareArguments?: (args: unknown) => z.input<TInputSchema>;
 };
 type StructuredToolExecuteResult<TOutputSchema extends ZodType<JuniorToolResult>> = z.input<TOutputSchema>;
-interface ContentOnlyToolResult {
+export interface ContentOnlyToolResult {
     content: Array<TextContent | ImageContent>;
     details?: never;
 }
@@ -19,9 +19,21 @@ type ContentZodToolDefinition<TInputSchema extends ZodTypeAny> = ZodToolDefiniti
     outputSchema?: undefined;
     execute?: (input: z.output<TInputSchema>, options: ToolExecuteOptions) => Promise<ContentOnlyToolResult> | ContentOnlyToolResult;
 };
+type StructuredZodTool<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>> = Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: JsonSchemaObject;
+    outputSchema: JsonSchemaObject;
+    prepareArguments(args: unknown): z.output<TInputSchema>;
+    execute?: (input: unknown, options: ToolExecuteOptions) => Promise<z.output<TOutputSchema>> | z.output<TOutputSchema>;
+};
+type ContentZodTool<TInputSchema extends ZodTypeAny> = Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: JsonSchemaObject;
+    outputSchema?: undefined;
+    prepareArguments(args: unknown): z.output<TInputSchema>;
+    execute?: (input: unknown, options: ToolExecuteOptions) => Promise<ContentOnlyToolResult> | ContentOnlyToolResult;
+};
 /**
  * Define a Junior-owned tool with Zod input parsing and JSON Schema parameters.
  */
-export declare function zodTool<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>>(definition: StructuredZodToolDefinition<TInputSchema, TOutputSchema>): AnyToolDefinition;
-export declare function zodTool<TInputSchema extends ZodTypeAny>(definition: ContentZodToolDefinition<TInputSchema>): AnyToolDefinition;
+export declare function zodTool<TInputSchema extends ZodTypeAny, TOutputSchema extends ZodType<JuniorToolResult>>(definition: StructuredZodToolDefinition<TInputSchema, TOutputSchema>): StructuredZodTool<TInputSchema, TOutputSchema>;
+export declare function zodTool<TInputSchema extends ZodTypeAny>(definition: ContentZodToolDefinition<TInputSchema>): ContentZodTool<TInputSchema>;
 export {};

package/dist/chat/tools/advisor/tool.d.ts

@@ -24,4 +24,44 @@ export interface AdvisorToolRuntimeContext {
 /** Build the advisor's read-only tool definition subset. */
 export declare function createAdvisorToolDefinitions(definitions: Record<string, AnyToolDefinition>): Record<string, AnyToolDefinition>;
 /** Create the advisor tool backed by conversation-scoped message history. */
-export declare function createAdvisorTool(context: AdvisorToolRuntimeContext): AnyToolDefinition;
+export declare function createAdvisorTool(context: AdvisorToolRuntimeContext): Omit<AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("@/chat/tools/definition").JsonSchemaObject;
+    outputSchema: import("@/chat/tools/definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        question: string;
+        context: string;
+    };
+    execute?: ((input: unknown, options: import("@/chat/tools/definition").ToolExecuteOptions) => {
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    } | Promise<{
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    }>) | undefined;
+};

package/dist/chat/tools/definition.d.ts

@@ -23,6 +23,11 @@ interface BaseToolDefinition<TInput, TInputSchema extends ToolInputSchema> {
         name: string;
         plugin: string;
     };
+    /** Stable model-facing catalog grouping for deferred tool discovery. */
+    source?: {
+        description: string;
+        id: string;
+    };
     description: string;
     exposure?: ToolExposure;
     inputSchema: TInputSchema;
@@ -56,6 +61,11 @@ export interface AnyToolDefinition {
         name: string;
         plugin: string;
     };
+    /** Stable model-facing catalog grouping for deferred tool discovery. */
+    source?: {
+        description: string;
+        id: string;
+    };
     description: string;
     exposure?: ToolExposure;
     inputSchema: ToolInputSchema;

package/dist/chat/tools/execute-tool.d.ts

@@ -1,3 +1,43 @@
 export declare const EXECUTE_TOOL_NAME = "executeTool";
 /** Create the model-visible dispatcher schema for catalog tools. */
-export declare function createExecuteToolTool(): import("./definition").AnyToolDefinition;
+export declare function createExecuteToolTool(): Omit<import("./definition").AnyToolDefinition, "inputSchema" | "outputSchema" | "prepareArguments" | "execute"> & {
+    inputSchema: import("./definition").JsonSchemaObject;
+    outputSchema: import("./definition").JsonSchemaObject;
+    prepareArguments(args: unknown): {
+        tool_name: string;
+        arguments?: Record<string, unknown> | undefined;
+    };
+    execute?: ((input: unknown, options: import("./definition").ToolExecuteOptions) => {
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    } | Promise<{
+        [x: string]: unknown;
+        ok: boolean;
+        status: "error" | "success";
+        target?: string | undefined;
+        data?: unknown;
+        truncated?: boolean | undefined;
+        continuation?: {
+            arguments: Record<string, unknown>;
+            reason?: string | undefined;
+        } | undefined;
+        error?: string | {
+            kind: string;
+            message: string;
+            retryable?: boolean | undefined;
+        } | undefined;
+    }>) | undefined;
+};