@sentry/junior 0.88.0 → 0.90.0

package/dist/chat/tools/sandbox/edit-file.d.ts

@@ -1,17 +1,41 @@
 import { type SandboxFileSystem } from "@/chat/tools/sandbox/file-utils";
 import { type TextReplacement } from "@/chat/tools/sandbox/text-edits";
 type EditReplacement = TextReplacement;
+type EditFailureKind = "not_found" | "old_text_not_found" | "old_text_not_unique" | "overlapping_edits" | "no_change" | "invalid_edit";
 interface EditFileResult {
     content: [{
         type: "text";
         text: string;
     }];
     details: {
+        data: {
+            diff: string;
+            first_changed_line?: number;
+            path: string;
+            replacements: number;
+        };
         diff: string;
         first_changed_line?: number;
         ok: true;
         path: string;
         replacements: number;
+        status: "success";
+        target: string;
+    } | {
+        data: {
+            path: string;
+            replacements: number;
+        };
+        error: {
+            kind: EditFailureKind;
+            message: string;
+            retryable: true;
+        };
+        ok: false;
+        path: string;
+        replacements: number;
+        status: "error";
+        target: string;
     };
 }
 interface EditFileInput {
@@ -27,11 +51,5 @@ export declare function editFile(params: {
     path: string;
 }): Promise<EditFileResult>;
 /** Create the sandbox edit tool definition exposed to the agent. */
-export declare function createEditFileTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TString;
-    edits: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        oldText: import("@sinclair/typebox").TString;
-        newText: import("@sinclair/typebox").TString;
-    }>>;
-}>>;
+export declare function createEditFileTool(): import("../definition").AnyToolDefinition;
 export {};

package/dist/chat/tools/sandbox/file-uploads.d.ts

@@ -0,0 +1,30 @@
+import type { SandboxWorkspace } from "@/chat/sandbox/workspace";
+/** Maximum single file size accepted by model-facing upload tools. */
+export declare const MAX_SANDBOX_FILE_UPLOAD_BYTES: number;
+/** Sandbox directory for generated files that later tools can consume. */
+export declare const SANDBOX_ARTIFACTS_DIR = "/tmp/junior/artifacts";
+/** Materialized sandbox file data ready for outbound upload boundaries. */
+export interface SandboxFileUpload {
+    bytes: number;
+    data: Buffer;
+    filename: string;
+    mimeType: string;
+    path: string;
+}
+/** Signal that a model-provided file path did not resolve in the active sandbox. */
+export declare class SandboxFileNotFoundError extends Error {
+    readonly path: string;
+    constructor(path: string);
+}
+/** Resolve model-provided sandbox paths against the sandbox workspace root. */
+export declare function normalizeSandboxPath(inputPath: string): string;
+/** Return the canonical sandbox artifact path for generated files. */
+export declare function sandboxArtifactPath(filename: string): string;
+/** Infer upload MIME type from an explicit value or filename extension. */
+export declare function inferMimeType(filename: string, explicitMimeType?: string): string;
+/** Read and validate one sandbox file for Slack/file reply upload. */
+export declare function readSandboxFileUpload(sandbox: SandboxWorkspace, input: {
+    path: string;
+    filename?: string;
+    mimeType?: string;
+}): Promise<SandboxFileUpload>;

package/dist/chat/tools/sandbox/file-utils.d.ts

@@ -3,14 +3,23 @@ export type { SandboxFileSystem };
 export declare const MAX_TEXT_CHARS = 60000;
 export type TextSearchResultDetails = {
     ok: true;
+    status?: "success";
+    target?: string;
     path: string;
     truncated: boolean;
+    data?: unknown;
 } | {
     ok: false;
-    error: "not_found";
+    status?: "error";
+    target?: string;
+    error: {
+        kind: "not_found";
+        message: string;
+    };
     path: string;
     missing_path?: string;
     truncated: false;
+    data?: unknown;
 };
 export interface TextSearchToolResult {
     content: [{

package/dist/chat/tools/sandbox/find-files.d.ts

@@ -1,13 +1,18 @@
-import { type SandboxFileSystem, type TextSearchResultDetails } from "@/chat/tools/sandbox/file-utils";
-interface FindFilesResult {
-    content: [{
-        type: "text";
-        text: string;
-    }];
+import { type SandboxFileSystem, type TextSearchResultDetails, type TextSearchToolResult } from "@/chat/tools/sandbox/file-utils";
+import { type JuniorToolResultEnvelope } from "@/chat/tool-support/structured-result";
+interface FindFilesSuccessResult {
+    content: JuniorToolResultEnvelope["content"];
     details: TextSearchResultDetails & {
+        data: {
+            files: string[];
+            file_count: number;
+            path: string;
+            truncation_reasons?: string[];
+        };
         result_limit_reached?: number;
     };
 }
+type FindFilesResult = FindFilesSuccessResult | TextSearchToolResult;
 /** Find workspace files with structured limits instead of ad hoc shell output. */
 export declare function findFiles(params: {
     fs: SandboxFileSystem;
@@ -16,9 +21,5 @@ export declare function findFiles(params: {
     pattern: string;
 }): Promise<FindFilesResult>;
 /** Create the sandbox file discovery tool definition exposed to the agent. */
-export declare function createFindFilesTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    pattern: import("@sinclair/typebox").TString;
-    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
-}>>;
+export declare function createFindFilesTool(): import("../definition").AnyToolDefinition;
 export {};

package/dist/chat/tools/sandbox/grep.d.ts

@@ -1,14 +1,28 @@
-import { type SandboxFileSystem, type TextSearchResultDetails } from "@/chat/tools/sandbox/file-utils";
-interface GrepResult {
+import { type SandboxFileSystem, type TextSearchResultDetails, type TextSearchToolResult } from "@/chat/tools/sandbox/file-utils";
+interface GrepResultData {
+    context: number;
+    glob?: string;
+    line_count: number;
+    lines: string[];
+    match_count: number;
+    pattern: string;
+    path: string;
+    truncation_reasons?: string[];
+}
+interface GrepSuccessResult {
     content: [{
         type: "text";
         text: string;
     }];
-    details: TextSearchResultDetails & {
+    details: Extract<TextSearchResultDetails, {
+        ok: true;
+    }> & {
+        data: GrepResultData;
         line_truncated?: boolean;
         match_limit_reached?: number;
     };
 }
+type GrepResult = GrepSuccessResult | TextSearchToolResult;
 /** Search workspace file contents with bounded, line-numbered output. */
 export declare function grepFiles(params: {
     context?: unknown;
@@ -21,13 +35,5 @@ export declare function grepFiles(params: {
     pattern: string;
 }): Promise<GrepResult>;
 /** Create the sandbox grep tool definition exposed to the agent. */
-export declare function createGrepTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    pattern: import("@sinclair/typebox").TString;
-    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    glob: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    ignoreCase: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    literal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
-    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
-}>>;
+export declare function createGrepTool(): import("../definition").AnyToolDefinition;
 export {};

package/dist/chat/tools/sandbox/list-dir.d.ts

@@ -1,13 +1,24 @@
-import { type SandboxFileSystem, type TextSearchResultDetails } from "@/chat/tools/sandbox/file-utils";
-interface ListDirResult {
+import { type SandboxFileSystem, type TextSearchResultDetails, type TextSearchToolResult } from "@/chat/tools/sandbox/file-utils";
+interface ListDirResultData {
+    entries: string[];
+    entry_count: number;
+    path: string;
+    total_entries: number;
+    truncation_reasons?: string[];
+}
+interface ListDirSuccessResult {
     content: [{
         type: "text";
         text: string;
     }];
-    details: TextSearchResultDetails & {
+    details: Extract<TextSearchResultDetails, {
+        ok: true;
+    }> & {
+        data: ListDirResultData;
         entry_limit_reached?: number;
     };
 }
+type ListDirResult = ListDirSuccessResult | TextSearchToolResult;
 /** List workspace directories without forcing the model through shell output. */
 export declare function listDir(params: {
     fs: SandboxFileSystem;
@@ -15,8 +26,5 @@ export declare function listDir(params: {
     path?: string;
 }): Promise<ListDirResult>;
 /** Create the sandbox directory listing tool definition exposed to the agent. */
-export declare function createListDirTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
-}>>;
+export declare function createListDirTool(): import("../definition").AnyToolDefinition;
 export {};

package/dist/chat/tools/sandbox/read-file.d.ts

@@ -1,32 +1,3 @@
-interface TextRangeResult {
-    content: string;
-    end_line?: number;
-    path: string;
-    start_line: number;
-    success: true;
-    total_lines: number;
-    truncated: boolean;
-    continuation?: string;
-}
-interface TextRangeMissingPathResult {
-    content: "";
-    error: "not_found";
-    path: string;
-    success: false;
-}
-/** Return a bounded line window so large files can be read incrementally. */
-export declare function sliceFileContent(params: {
-    content: string;
-    limit?: unknown;
-    offset?: unknown;
-    path: string;
-}): TextRangeResult;
-/** Return a model-visible result for expected missing read targets. */
-export declare function missingFileResult(path: string): TextRangeMissingPathResult;
+export { missingFileResult, sliceFileContent, } from "@/chat/tool-support/text-range-result";
 /** Create the sandbox read tool definition exposed to the agent. */
-export declare function createReadFileTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TString;
-    offset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
-}>>;
-export {};
+export declare function createReadFileTool(): import("../definition").AnyToolDefinition;

package/dist/chat/tools/sandbox/write-file.d.ts

@@ -1,5 +1,2 @@
 /** Create the sandbox full-file write tool definition exposed to the agent. */
-export declare function createWriteFileTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    path: import("@sinclair/typebox").TString;
-    content: import("@sinclair/typebox").TString;
-}>>;
+export declare function createWriteFileTool(): import("../definition").AnyToolDefinition;

package/dist/chat/tools/search-tools.d.ts

@@ -0,0 +1,4 @@
+import type { AnyToolDefinition } from "@/chat/tools/definition";
+export declare const SEARCH_TOOLS_NAME = "searchTools";
+/** Create the model-visible search tool for the executable tool catalog. */
+export declare function createSearchToolsTool(catalogTools: Record<string, AnyToolDefinition>): AnyToolDefinition;

package/dist/chat/tools/skill/call-mcp-tool.d.ts

@@ -4,8 +4,5 @@ interface CallMcpToolManager {
     getResolvedActiveTools(): ManagedMcpTool[];
 }
 /** Create the stable dispatcher for active MCP provider tools. */
-export declare function createCallMcpToolTool(mcpToolManager: CallMcpToolManager): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    tool_name: import("@sinclair/typebox").TString;
-    arguments: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
-}>>;
+export declare function createCallMcpToolTool(mcpToolManager: CallMcpToolManager): import("../definition").AnyToolDefinition;
 export {};

package/dist/chat/tools/skill/load-skill.d.ts

@@ -1,6 +1,7 @@
 import { type Skill, type SkillMetadata } from "@/chat/skills";
 export type LoadSkillResult = {
-    ok?: boolean;
+    ok: boolean;
+    status: "error" | "success";
     error?: string;
     available_skills?: string[];
     skill_name?: string;
@@ -12,11 +13,9 @@ export type LoadSkillResult = {
     instructions?: string;
     mcp_provider?: string;
     available_tool_count?: number;
-};
+} & Record<string, unknown>;
 export type LoadSkillMetadata = Pick<LoadSkillResult, "mcp_provider" | "available_tool_count">;
 /** Create the skill-loading tool that injects skill instructions and activates provider catalogs. */
 export declare function createLoadSkillTool(availableSkills: SkillMetadata[], options?: {
     onSkillLoaded?: (skill: Skill) => void | LoadSkillMetadata | Promise<void | LoadSkillMetadata>;
-}): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    skill_name: import("@sinclair/typebox").TString;
-}>>;
+}): import("../definition").AnyToolDefinition;

package/dist/chat/tools/skill/search-mcp-tools.d.ts

@@ -12,9 +12,5 @@ interface SearchMcpToolManager {
     getAvailableProviderCatalog(): ProviderSummary[];
 }
 /** Create the progressive MCP catalog search tool used before callMcpTool. */
-export declare function createSearchMcpToolsTool(mcpToolManager: SearchMcpToolManager): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    provider: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    max_results: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
-}>>;
+export declare function createSearchMcpToolsTool(mcpToolManager: SearchMcpToolManager): import("../definition").AnyToolDefinition;
 export {};

package/dist/chat/tools/system-time.d.ts

@@ -1 +1 @@
-export declare function createSystemTimeTool(): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{}>>;
+export declare function createSystemTimeTool(): import("./definition").AnyToolDefinition;

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

@@ -7,6 +7,7 @@ import type { ThreadArtifactsState } from "@/chat/state/artifacts";
 import type { Skill } from "@/chat/skills";
 import type { LoadSkillMetadata } from "@/chat/tools/skill/load-skill";
 import type { AdvisorToolRuntimeContext } from "@/chat/tools/advisor/tool";
+import type { JuniorToolResult } from "@/chat/tool-support/structured-result";
 import type { LocalRequester, Requester, SlackRequester } from "@/chat/requester";
 export interface ImageGenerateToolDeps {
     fetch?: typeof fetch;
@@ -15,18 +16,27 @@ export interface WebFetchToolDeps {
     execute?: (input: {
         url: string;
         max_chars?: number;
-    }) => Promise<unknown> | unknown;
+    }) => Promise<JuniorToolResult> | JuniorToolResult;
 }
 export interface WebSearchToolDeps {
     execute?: (input: {
         query: string;
         max_results?: number;
-    }) => Promise<unknown> | unknown;
+    }) => Promise<JuniorToolResult> | JuniorToolResult;
+}
+/** Sandbox file handle returned to the model after a generated artifact is written. */
+export interface GeneratedArtifactFileRef {
+    bytes: number;
+    filename: string;
+    mimeType?: string;
+    path: string;
 }
 export interface ToolHooks {
-    getGeneratedFile?: (filename: string) => FileUpload | undefined;
-    onGeneratedArtifactFiles?: (files: FileUpload[]) => void;
-    onGeneratedFiles?: (files: FileUpload[]) => void;
+    /**
+     * Materialize generated files and return sandbox paths that exist before the
+     * generating tool reports success.
+     */
+    writeGeneratedArtifacts?: (files: FileUpload[]) => GeneratedArtifactFileRef[] | Promise<GeneratedArtifactFileRef[]>;
     onArtifactStatePatch?: (patch: Partial<ThreadArtifactsState>) => void | Promise<void>;
     onSkillLoaded?: (skill: Skill) => void | LoadSkillMetadata | Promise<void | LoadSkillMetadata>;
     toolOverrides?: {

package/dist/chat/tools/web/fetch-content.d.ts

@@ -6,7 +6,9 @@ export interface WebFetchResponseContent {
     truncated: boolean;
     extractedChars: number;
 }
-export interface WebFetchResponse {
+export type WebFetchResponse = {
+    ok: true;
+    status: "success";
     url: string;
     content: string;
     title?: string;
@@ -14,7 +16,7 @@ export interface WebFetchResponse {
     source_bytes: number;
     extracted_chars: number;
     truncated: boolean;
-}
+} & Record<string, unknown>;
 /** Extract readable content and metadata from a fetched response body. */
 export declare function extractContentDetails(body: string, contentType: string, maxChars: number): WebFetchResponseContent;
 /** Extract readable content from a fetched response body, converting HTML to markdown. */

package/dist/chat/tools/web/fetch-tool.d.ts

@@ -1,5 +1,5 @@
 import type { ToolHooks } from "@/chat/tools/types";
-export declare function createWebFetchTool(hooks: ToolHooks): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    url: import("@sinclair/typebox").TString;
-    max_chars: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
-}>>;
+/** Create the fetch tool with delivery guidance scoped to active file-send capability. */
+export declare function createWebFetchTool(hooks: ToolHooks, options?: {
+    canSendFilesToActiveConversation?: boolean;
+}): import("../definition").AnyToolDefinition;

package/dist/chat/tools/web/image-generate.d.ts

@@ -1,4 +1,5 @@
 import type { ImageGenerateToolDeps, ToolHooks } from "@/chat/tools/types";
-export declare function createImageGenerateTool(hooks: ToolHooks, deps?: ImageGenerateToolDeps): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    prompt: import("@sinclair/typebox").TString;
-}>>;
+/** Create the image tool with sandbox artifact guidance matched to file-send capability. */
+export declare function createImageGenerateTool(hooks: Required<Pick<ToolHooks, "writeGeneratedArtifacts">>, options?: {
+    canSendFilesToActiveConversation?: boolean;
+}, deps?: ImageGenerateToolDeps): import("../definition").AnyToolDefinition;

package/dist/chat/tools/web/search.d.ts

@@ -1,5 +1,2 @@
 import type { WebSearchToolDeps } from "@/chat/tools/types";
-export declare function createWebSearchTool(override?: WebSearchToolDeps): import("@/chat/tools/definition").ToolDefinition<import("@sinclair/typebox").TObject<{
-    query: import("@sinclair/typebox").TString;
-    max_results: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
-}>>;
+export declare function createWebSearchTool(override?: WebSearchToolDeps): import("../definition").AnyToolDefinition;

package/dist/{chunk-4IXHIV37.js → chunk-2S7M37HY.js}

@@ -1,16 +1,14 @@
+import {
+  getChatConfig
+} from "./chunk-HXL2ZV74.js";
 import {
   parseDestination,
   sameDestination
-} from "./chunk-AHLSXMOU.js";
-import {
-  getChatConfig
-} from "./chunk-S35CPNPT.js";
+} from "./chunk-GHGPTPBL.js";
 import {
+  normalizeIdentityEmail,
   parseStoredSlackRequester
-} from "./chunk-KQKIA4CU.js";
-import {
-  normalizeIdentityEmail
-} from "./chunk-VMBZFPZM.js";
+} from "./chunk-ZUK7BL63.js";
 
 // src/chat/conversations/sql/store.ts
 import { randomUUID as randomUUID2 } from "crypto";

package/dist/{chunk-L7OHKDOX.js → chunk-3MPOMK3K.js}

@@ -1,12 +1,58 @@
 import {
   toOptionalString
-} from "./chunk-FTMXFBDC.js";
+} from "./chunk-OB42YVAE.js";
+import {
+  parseSlackChannelId,
+  parseSlackMessageTs,
+  parseSlackTeamId
+} from "./chunk-LFLTJQVR.js";
 
 // src/chat/slack/context.ts
+import { z } from "zod";
 function toTrimmedSlackString(value) {
   const normalized = toOptionalString(value);
   return normalized?.trim() || void 0;
 }
+var slackMessageEnvelopeSchema = z.object({
+  raw: z.unknown().optional()
+});
+var rawSlackMessageSchema = z.object({
+  channel: z.unknown().optional(),
+  message: z.unknown().optional(),
+  team: z.unknown().optional(),
+  team_id: z.unknown().optional(),
+  thread_ts: z.unknown().optional(),
+  ts: z.unknown().optional(),
+  user_team: z.unknown().optional()
+});
+var nestedRawSlackMessageSchema = z.object({
+  ts: z.unknown().optional()
+});
+function readSlackRawMessageContext(message) {
+  const envelope = slackMessageEnvelopeSchema.safeParse(message);
+  if (!envelope.success) {
+    return void 0;
+  }
+  const raw = rawSlackMessageSchema.safeParse(envelope.data.raw);
+  if (!raw.success) {
+    return void 0;
+  }
+  const nestedMessage = nestedRawSlackMessageSchema.safeParse(raw.data.message);
+  const channelId = parseSlackChannelId(raw.data.channel);
+  const threadTs = parseSlackMessageTs(raw.data.thread_ts);
+  const messageTs = parseSlackMessageTs(raw.data.ts);
+  const nestedMessageTs = nestedMessage.success && parseSlackMessageTs(nestedMessage.data.ts);
+  const teamId = parseSlackTeamId(raw.data.team_id) ?? parseSlackTeamId(raw.data.team);
+  const authorTeamId = parseSlackTeamId(raw.data.user_team);
+  return {
+    ...channelId ? { channelId } : {},
+    ...threadTs ? { threadTs } : {},
+    ...messageTs ? { messageTs } : {},
+    ...nestedMessageTs ? { nestedMessageTs } : {},
+    ...teamId ? { teamId } : {},
+    ...authorTeamId ? { authorTeamId } : {}
+  };
+}
 function parseSlackThreadId(threadId) {
   const normalizedThreadId = toTrimmedSlackString(threadId);
   if (!normalizedThreadId) {
@@ -16,8 +62,8 @@ function parseSlackThreadId(threadId) {
   if (parts.length !== 3 || parts[0] !== "slack") {
     return void 0;
   }
-  const channelId = toTrimmedSlackString(parts[1]);
-  const threadTs = toTrimmedSlackString(parts[2]);
+  const channelId = parseSlackChannelId(parts[1]);
+  const threadTs = parseSlackMessageTs(parts[2]);
   if (!channelId || !threadTs) {
     return void 0;
   }
@@ -27,7 +73,7 @@ function resolveSlackChannelIdFromThreadId(threadId) {
   return parseSlackThreadId(threadId)?.channelId;
 }
 function resolveSlackChannelIdFromMessage(message) {
-  const messageChannelId = toTrimmedSlackString(
+  const messageChannelId = parseSlackChannelId(
     message.channelId
   );
   if (messageChannelId) {
@@ -35,7 +81,7 @@ function resolveSlackChannelIdFromMessage(message) {
   }
   const raw = message.raw;
   if (raw && typeof raw === "object") {
-    const rawChannel = toTrimmedSlackString(
+    const rawChannel = parseSlackChannelId(
       raw.channel
     );
     if (rawChannel) {
@@ -58,11 +104,15 @@ function privateNarrowingFromChannelId(channelId) {
   return normalized.startsWith("D") || normalized.startsWith("G") ? "private" : void 0;
 }
 function privateNarrowingFromConversationId(conversationId) {
-  if (!conversationId?.trim()) return void 0;
-  const slackThread = parseSlackThreadId(conversationId);
+  const normalized = conversationId?.trim();
+  if (!normalized) return void 0;
+  const slackThread = parseSlackThreadId(normalized);
   if (slackThread) {
     return privateNarrowingFromChannelId(slackThread.channelId);
   }
+  if (normalized.startsWith("slack:")) {
+    return void 0;
+  }
   return "private";
 }
 function resolveConversationPrivacy(input) {
@@ -214,6 +264,7 @@ function toGenAiMessagesTraceAttributes(prefix, messages) {
 }
 
 export {
+  readSlackRawMessageContext,
   parseSlackThreadId,
   resolveSlackChannelIdFromThreadId,
   resolveSlackChannelIdFromMessage,

package/dist/{chunk-V6XDCS3X.js → chunk-5GBUZI6M.js}

@@ -3,16 +3,16 @@ import {
 } from "./chunk-G3E7SCME.js";
 import {
   getStateAdapter
-} from "./chunk-YPAE5RH3.js";
+} from "./chunk-RS6ANWVT.js";
 import {
   toOptionalTrimmed
-} from "./chunk-S35CPNPT.js";
+} from "./chunk-HXL2ZV74.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-KBFQXJL4.js";
+} from "./chunk-XP7F4LYB.js";
 import {
   withSpan
-} from "./chunk-VMBZFPZM.js";
+} from "./chunk-ZUK7BL63.js";
 
 // src/chat/sandbox/runtime-dependency-snapshots.ts
 import { createHash } from "crypto";

package/dist/{chunk-7ES37H6U.js → chunk-AN2437E3.js}

@@ -1,12 +1,12 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-KBFQXJL4.js";
+} from "./chunk-XP7F4LYB.js";
+import {
+  logWarn
+} from "./chunk-ZUK7BL63.js";
 import {
   skillRoots
 } from "./chunk-6APU57E6.js";
-import {
-  logWarn
-} from "./chunk-VMBZFPZM.js";
 
 // src/chat/skills.ts
 import fs from "fs/promises";