@sentry/junior 0.160.0 → 0.161.0

package/dist/{chunk-M5HCOMDR.js → chunk-OYQEO72I.js}

@@ -7,7 +7,7 @@ import {
   PluginCredentialFailureError,
   agentNameSchema,
   createPluginAuthOrchestration
-} from "./chunk-756F567I.js";
+} from "./chunk-OY2DBUV4.js";
 import {
   authorizationId
 } from "./chunk-DIB4GX3G.js";
@@ -32,7 +32,7 @@ import {
   searchSlackUsers,
   selectPluginGrant,
   toMcpProviderError
-} from "./chunk-PVIM2RWO.js";
+} from "./chunk-V67ORYKQ.js";
 import {
   RetryableDeliveryError,
   actorFromRun,
@@ -48,7 +48,7 @@ import {
   getSlackMessagePermalink,
   resolveBaseUrl,
   uploadFilesToConversation
-} from "./chunk-P7W3ZL5J.js";
+} from "./chunk-VXFDVY4C.js";
 import {
   parseSandboxEgressAuthRequiredSignal,
   parseSandboxEgressPermissionDeniedSignal,
@@ -74,7 +74,7 @@ import {
   runNonInteractiveCommand,
   throwSandboxOperationError,
   wrapSandboxSetupError
-} from "./chunk-BGVQGEKB.js";
+} from "./chunk-RULQD7OX.js";
 import {
   SCHEDULED_TASK_SYSTEM_ACTOR,
   compactEventTask,
@@ -107,10 +107,10 @@ import {
   scheduledTaskAttributes,
   storeAttachments,
   writableEventTask
-} from "./chunk-RJGRXDA7.js";
+} from "./chunk-ZBCLWBMV.js";
 import {
   parseSlackThreadId
-} from "./chunk-56TFPTZU.js";
+} from "./chunk-YSWHAOPQ.js";
 import {
   AGENTS_REMOVAL_NOTICE,
   AGENTS_REPLACEMENT_NOTICE,
@@ -181,7 +181,7 @@ import {
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   truncateText
-} from "./chunk-RLOXMHLA.js";
+} from "./chunk-STZVUVMS.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS
 } from "./chunk-3Y47VMHV.js";
@@ -189,24 +189,22 @@ import {
   privateTraceResultAttributes
 } from "./chunk-UIE3R5XU.js";
 import {
+  SlackActionError,
   createPluginHookRunner,
+  downloadPrivateSlackFile,
   getDashboardTaskLink,
+  getFilePermalink,
   getPluginSystemPromptContributions,
   getPluginTools,
   getPluginUserPromptContributions,
-  getSlackToolContext,
-  readActorIdentity,
-  resolveChannelCapabilities
-} from "./chunk-U26KRMYX.js";
-import {
-  SlackActionError,
-  downloadPrivateSlackFile,
-  getFilePermalink,
   getSlackClient,
+  getSlackToolContext,
   isConversationScopedChannel,
   normalizeSlackConversationId,
+  readActorIdentity,
+  resolveChannelCapabilities,
   withSlackRetries
-} from "./chunk-OUAZDZTZ.js";
+} from "./chunk-MNY5M7RB.js";
 import {
   KNOWN_CONVERSATION_EVENT_TYPES,
   contextProvenance,
@@ -218,10 +216,11 @@ import {
   instructionActors,
   instructionProvenanceFor,
   sameActorIdentity
-} from "./chunk-JQZIUESN.js";
+} from "./chunk-U2XOBFDK.js";
 import {
+  juniorArtifacts,
   juniorIdentities
-} from "./chunk-4UO3UAW7.js";
+} from "./chunk-FLMD25Y5.js";
 import {
   SANDBOX_DATA_ROOT,
   SANDBOX_SKILLS_ROOT,
@@ -233,7 +232,7 @@ import {
 } from "./chunk-EM225ITJ.js";
 import {
   getStateAdapter
-} from "./chunk-UNDTW2PY.js";
+} from "./chunk-IYFKONIL.js";
 import {
   ACTIVE_TURN_COMPACTION_SUMMARY_PREFIX,
   COMPACTION_SUMMARY_PREFIX,
@@ -266,7 +265,7 @@ import {
   resolveGatewayCredential,
   resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-J77DLAPE.js";
+} from "./chunk-RVENVPNO.js";
 import {
   canExposeConversationPayload,
   resolveConversationPrivacy,
@@ -276,16 +275,16 @@ import {
   toGenAiMessagesTraceAttributes,
   toGenAiPayloadMetadata,
   toGenAiPayloadTraceAttributes
-} from "./chunk-TBRJGMTO.js";
+} from "./chunk-EAIQBR66.js";
 import {
   discoverSkills,
   findSkillByName,
   loadSkillsByName,
   parseSkillInvocation
-} from "./chunk-XPX3DYG7.js";
+} from "./chunk-DGKLYDX7.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-2SFMRMDV.js";
+} from "./chunk-CGAIDDLD.js";
 import {
   CredentialUnavailableError,
   OAuthProviderError,
@@ -293,7 +292,7 @@ import {
   getOAuthProviderErrorAttributes,
   resolveAuthTokenPlaceholder,
   resolvePluginCommandEnv
-} from "./chunk-42E7432W.js";
+} from "./chunk-6WTDZKFR.js";
 import {
   credentialUserSubjectId
 } from "./chunk-BDUENQD3.js";
@@ -321,7 +320,7 @@ import {
   summarizeMessageText,
   withLogContext,
   withSpan
-} from "./chunk-ZNBGWMVQ.js";
+} from "./chunk-DNSIU27S.js";
 import {
   startInactiveSpan,
   withActiveSpan
@@ -1732,7 +1731,6 @@ function buildOutputSection(platform) {
       `<output format="markdown">`,
       "- Start with the answer or result, not internal process narration.",
       "- Use concise Markdown suitable for terminal output: short paragraphs, bullets, links, and fenced code blocks when helpful.",
-      "- When you mention a pull request, include a direct link. Prefer the full PR URL or a Markdown link; do not leave bare `PR #123` text without a URL or repo.",
       "- End every turn with a final user-facing response.",
       "</output>"
     ].join("\n");
@@ -1742,7 +1740,6 @@ function buildOutputSection(platform) {
     "- Default to the shortest complete reply\u2014usually 1\u20135 sentences and under 800 characters. Include only the outcome, decisive evidence, and any blocker or required next action. If useful detail would exceed that, put it in a Slack canvas and reply with the link. An explicit user request for detail overrides this target.",
     "- Start with the answer or result, not internal process narration.",
     "- Use Slack-flavored Markdown: **bold** section labels, `code`, [text](url) links, bullet lists, and fenced code blocks. No hash-prefixed headings and no tables. When the answer primarily lists several URLs, show each URL bare instead of as a labeled link.",
-    "- When you mention a pull request, include a direct link. Prefer the full PR URL or a Markdown link; `owner/repo#number` is also accepted and is linkified on delivery. Do not leave bare `PR #123` text without a URL or repo.",
     "- End every turn with a final user-facing markdown response unless the Slack action rules allow a no-reply completion.",
     "</output>"
   ].join("\n");
@@ -3982,7 +3979,7 @@ function parseToolInput(schema, args) {
   return result.data;
 }
 function zodTool(definition) {
-  const { inputSchema: inputSchema2, outputSchema: outputSchema5, prepareArguments, execute, ...toolDef } = definition;
+  const { inputSchema: inputSchema2, outputSchema: outputSchema7, prepareArguments, execute, ...toolDef } = definition;
   let modelInputSchema;
   try {
     modelInputSchema = z3.toJSONSchema(inputSchema2);
@@ -3993,9 +3990,9 @@ function zodTool(definition) {
     );
   }
   let modelOutputSchema;
-  if (outputSchema5) {
+  if (outputSchema7) {
     try {
-      modelOutputSchema = z3.toJSONSchema(outputSchema5);
+      modelOutputSchema = z3.toJSONSchema(outputSchema7);
     } catch (error) {
       throw new TypeError(
         "zodTool() outputSchema must be representable as JSON Schema.",
@@ -4019,7 +4016,7 @@ function zodTool(definition) {
           input,
           options
         );
-        if (!outputSchema5) {
+        if (!outputSchema7) {
           if (isContentOnlyToolResult(result)) {
             return result;
           }
@@ -4030,10 +4027,10 @@ function zodTool(definition) {
         if (isStructuredToolResultEnvelope(result)) {
           return {
             content: parseToolContent(result.content),
-            details: outputSchema5.parse(result.details)
+            details: outputSchema7.parse(result.details)
           };
         }
-        return outputSchema5.parse(result);
+        return outputSchema7.parse(result);
       }
     } : {}
   };
@@ -6494,7 +6491,7 @@ var McpToolManager = class {
     return client;
   }
   toManagedTool(plugin, client, tool) {
-    const outputSchema5 = toOptionalRecord(tool.outputSchema);
+    const outputSchema7 = toOptionalRecord(tool.outputSchema);
     const annotations = tool.annotations;
     const missingAnnotationKeys = missingToolAnnotationKeys(annotations);
     if (missingAnnotationKeys.length > 0) {
@@ -6511,7 +6508,7 @@ var McpToolManager = class {
       provider: plugin.manifest.name,
       rawName: tool.name,
       ...tool.title?.trim() ? { title: tool.title.trim() } : {},
-      ...outputSchema5 ? { outputSchema: outputSchema5 } : {},
+      ...outputSchema7 ? { outputSchema: outputSchema7 } : {},
       ...annotations ? { annotations } : {},
       execute: async (args, options) => {
         const resolvedArgs = typeof args === "object" && args !== null ? args : {};
@@ -12307,28 +12304,318 @@ function getTimeZoneOffsetMinutes(timestampMs, timezone) {
   return Math.round((timestampMs - asUtcMs) / 6e4);
 }
 
-// src/chat/tools/search-conversation-events.ts
+// src/chat/tools/publish-image.ts
 import { z as z56 } from "zod";
+
+// src/chat/artifacts/store.ts
+import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
+import { and as and2, eq as eq2, isNull } from "drizzle-orm";
+var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var IMAGE_TYPES = {
+  gif: "image/gif",
+  jpg: "image/jpeg",
+  png: "image/png",
+  webp: "image/webp"
+};
+var FILENAME_RE = /^([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\.(gif|jpg|png|webp)$/i;
+function detectImageType(data) {
+  if (data.length >= 8 && data.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return { contentType: IMAGE_TYPES.png, extension: "png" };
+  }
+  if (data.length >= 3 && data[0] === 255 && data[1] === 216 && data[2] === 255) {
+    return { contentType: IMAGE_TYPES.jpg, extension: "jpg" };
+  }
+  if (data.length >= 6 && (data.subarray(0, 6).toString("ascii") === "GIF87a" || data.subarray(0, 6).toString("ascii") === "GIF89a")) {
+    return { contentType: IMAGE_TYPES.gif, extension: "gif" };
+  }
+  if (data.length >= 12 && data.subarray(0, 4).toString("ascii") === "RIFF" && data.subarray(8, 12).toString("ascii") === "WEBP") {
+    return { contentType: IMAGE_TYPES.webp, extension: "webp" };
+  }
+  return null;
+}
+function artifactKey(filename) {
+  return `artifacts/${filename}`;
+}
+function parseArtifactFilename(filename) {
+  const match = filename.match(FILENAME_RE);
+  if (!match) return null;
+  return {
+    id: match[1].toLowerCase(),
+    ext: match[2].toLowerCase()
+  };
+}
+function artifactFilenameFromRef(ref) {
+  const trimmed = ref.trim();
+  if (FILENAME_RE.test(trimmed)) {
+    const parsed = parseArtifactFilename(trimmed);
+    return parsed ? `${parsed.id}.${parsed.ext}` : null;
+  }
+  try {
+    const url = new URL(trimmed);
+    const marker = "/public/artifacts/";
+    const index = url.pathname.lastIndexOf(marker);
+    if (index === -1) return null;
+    const filename = url.pathname.slice(index + marker.length);
+    const parsed = parseArtifactFilename(filename);
+    return parsed ? `${parsed.id}.${parsed.ext}` : null;
+  } catch {
+    return null;
+  }
+}
+function resolvePublicBaseUrl(publicBaseUrl) {
+  const baseUrl = publicBaseUrl.trim().replace(/\/+$/, "");
+  let parsedBaseUrl;
+  try {
+    parsedBaseUrl = new URL(baseUrl);
+  } catch {
+    throw new Error("public base URL must be an absolute HTTP(S) URL");
+  }
+  if (parsedBaseUrl.protocol !== "http:" && parsedBaseUrl.protocol !== "https:") {
+    throw new Error("public base URL must use HTTP(S)");
+  }
+  return baseUrl;
+}
+async function publishImage(args) {
+  if (args.body.byteLength === 0) {
+    throw new ToolInputError("image is empty");
+  }
+  if (args.body.byteLength > MAX_IMAGE_BYTES) {
+    throw new ToolInputError(
+      `image exceeds ${MAX_IMAGE_BYTES} bytes (${args.body.byteLength} bytes)`
+    );
+  }
+  const imageType = detectImageType(args.body);
+  if (!imageType) {
+    throw new ToolInputError(
+      "unsupported image format; use PNG, JPEG, GIF, or WebP"
+    );
+  }
+  const baseUrl = resolvePublicBaseUrl(args.publicBaseUrl);
+  const sha256 = createHash5("sha256").update(args.body).digest("hex");
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const [existing] = await args.db.db().select({
+    id: juniorArtifacts.id
+  }).from(juniorArtifacts).where(
+    and2(
+      eq2(juniorArtifacts.conversationId, args.conversationId),
+      eq2(juniorArtifacts.sha256, sha256)
+    )
+  );
+  const id = existing?.id ?? randomUUID3();
+  const filename = `${id}.${imageType.extension}`;
+  const storageKey = artifactKey(filename);
+  await args.storage.put({
+    body: args.body,
+    contentType: imageType.contentType,
+    key: storageKey
+  });
+  const [row] = await args.db.db().insert(juniorArtifacts).values({
+    bytes: args.body.byteLength,
+    contentType: imageType.contentType,
+    conversationId: args.conversationId,
+    createdAt: now,
+    deleteRequestedAt: null,
+    ext: imageType.extension,
+    id,
+    public: true,
+    sha256,
+    storageKey
+  }).onConflictDoUpdate({
+    target: [juniorArtifacts.conversationId, juniorArtifacts.sha256],
+    set: {
+      bytes: args.body.byteLength,
+      contentType: imageType.contentType,
+      deleteRequestedAt: null,
+      ext: imageType.extension,
+      public: true
+      // Keep the winning row's id/storage key. A raced put may leave an
+      // unused object; that is fine for mvp.
+    }
+  }).returning({
+    ext: juniorArtifacts.ext,
+    id: juniorArtifacts.id
+  });
+  if (!row) {
+    throw new Error("failed to publish artifact row");
+  }
+  return {
+    bytes: args.body.byteLength,
+    contentType: imageType.contentType,
+    url: `${baseUrl}/public/artifacts/${row.id}.${row.ext}`
+  };
+}
+async function unpublishArtifact(args) {
+  const filename = artifactFilenameFromRef(args.ref);
+  if (!filename) {
+    throw new ToolInputError(
+      "artifact ref must be a public artifact URL or <id>.<ext> filename"
+    );
+  }
+  const parsed = parseArtifactFilename(filename);
+  if (!parsed) {
+    throw new ToolInputError(
+      "artifact ref must be a public artifact URL or <id>.<ext> filename"
+    );
+  }
+  const now = args.now ?? /* @__PURE__ */ new Date();
+  const updated = await args.db.db().update(juniorArtifacts).set({ deleteRequestedAt: now }).where(
+    and2(
+      eq2(juniorArtifacts.id, parsed.id),
+      eq2(juniorArtifacts.conversationId, args.conversationId)
+    )
+  ).returning({ id: juniorArtifacts.id });
+  if (updated.length === 0) {
+    throw new ToolInputError(
+      `artifact not found for this conversation: ${filename}`
+    );
+  }
+  return { filename };
+}
+async function readPublicArtifact(args) {
+  const parsed = parseArtifactFilename(args.filename);
+  if (!parsed) return null;
+  const [row] = await args.db.db().select({
+    contentType: juniorArtifacts.contentType,
+    storageKey: juniorArtifacts.storageKey
+  }).from(juniorArtifacts).where(
+    and2(
+      eq2(juniorArtifacts.id, parsed.id),
+      eq2(juniorArtifacts.public, true),
+      isNull(juniorArtifacts.deleteRequestedAt)
+    )
+  );
+  if (!row) return null;
+  const body = await args.storage.get(row.storageKey);
+  if (!body) return null;
+  return { body, contentType: row.contentType };
+}
+function publicArtifactHeaders(contentType) {
+  return new Headers({
+    // Keep TTL short so unpublish can take effect. Do not mark immutable.
+    "cache-control": "public, max-age=300, must-revalidate",
+    "content-type": contentType,
+    "x-content-type-options": "nosniff"
+  });
+}
+function unpublishedArtifactHeaders() {
+  return new Headers({
+    "cache-control": "private, no-store",
+    "x-content-type-options": "nosniff"
+  });
+}
+
+// src/chat/tools/publish-image.ts
+var outputSchema5 = juniorToolOutputSchema.extend({
+  bytes: z56.number().int().positive(),
+  content_type: z56.string().min(1),
+  public: z56.literal(true),
+  url: z56.string().url()
+});
+function createPublishImageTool(args) {
+  return zodTool({
+    annotations: {
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    approvalMode: "review",
+    description: "Publish one sandbox image to a durable public HTTPS URL. Anyone on the internet with the URL can view the image. Use only when an external destination needs a public image URL. Do not use for private file sharing or private conversation storage. Supports PNG, JPEG, GIF, and WebP up to 10 MB.",
+    describeProposal: ({ path: path8 }) => `Publish sandbox image ${path8} to a public internet URL.`,
+    executionMode: "sequential",
+    inputSchema: z56.object({
+      path: z56.string().min(1).describe("Exact sandbox path of an existing image file.")
+    }).strict(),
+    outputSchema: outputSchema5,
+    async execute({ path: path8 }) {
+      const publicBaseUrl = (args.publicBaseUrl ?? resolveBaseUrl)()?.trim();
+      if (!publicBaseUrl) {
+        throw new Error(
+          "publishImage requires JUNIOR_BASE_URL or a Vercel deployment URL."
+        );
+      }
+      const targetPath = normalizeSandboxPath(path8);
+      const body = await args.workspace.readFileToBuffer({ path: targetPath });
+      if (!body) {
+        throw new SandboxFileNotFoundError(targetPath);
+      }
+      const image = await publishImage({
+        body,
+        conversationId: args.conversationId,
+        db: args.db,
+        publicBaseUrl,
+        storage: args.storage
+      });
+      return {
+        bytes: image.bytes,
+        content_type: image.contentType,
+        public: true,
+        url: image.url
+      };
+    }
+  });
+}
+
+// src/chat/tools/unpublish-image.ts
+import { z as z57 } from "zod";
+var outputSchema6 = juniorToolOutputSchema.extend({
+  filename: z57.string().min(1),
+  unpublished: z57.literal(true)
+});
+function createUnpublishImageTool(args) {
+  return zodTool({
+    annotations: {
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false,
+      readOnlyHint: false
+    },
+    approvalMode: "review",
+    description: "Unpublish one public image previously published in this conversation so its public URL stops serving. Pass the public artifact URL or `<id>.<ext>` filename. Only images owned by this conversation can be unpublished. Republishing the same image bytes later in this conversation restores a live URL for this conversation. Does not remove copies already fetched by browsers or GitHub.",
+    describeProposal: ({ ref }) => `Unpublish public image ${ref}.`,
+    executionMode: "sequential",
+    inputSchema: z57.object({
+      ref: z57.string().min(1).describe(
+        "Public artifact URL or artifact filename (`<id>.<ext>`)."
+      )
+    }).strict(),
+    outputSchema: outputSchema6,
+    async execute({ ref }) {
+      const result = await unpublishArtifact({
+        conversationId: args.conversationId,
+        db: args.db,
+        ref
+      });
+      return {
+        filename: result.filename,
+        unpublished: true
+      };
+    }
+  });
+}
+
+// src/chat/tools/search-conversation-events.ts
+import { z as z58 } from "zod";
 var DEFAULT_LIMIT3 = 25;
 var MAX_LIMIT = 100;
 var MAX_EVENT_DATA_BYTES = 4e3;
 var MAX_EVENTS_JSON_BYTES = 2e4;
 var MAX_IDENTITY_CHARS = 256;
 var textEncoder = new TextEncoder();
-var knownEventTypeSchema = z56.enum(KNOWN_CONVERSATION_EVENT_TYPES);
-var projectedEventSchema = z56.object({
-  seq: z56.number().int().nonnegative().describe("Stable event position for pagination."),
-  history_version: z56.number().int().nonnegative().describe("Agent history generation after replacement."),
-  created_at: z56.iso.datetime().describe("When the event was recorded."),
-  idempotency_key: z56.string().min(1).optional().describe("Retry-stable event identity, when assigned."),
-  data: z56.record(z56.string(), z56.unknown()).describe("Bounded event data.")
+var knownEventTypeSchema = z58.enum(KNOWN_CONVERSATION_EVENT_TYPES);
+var projectedEventSchema = z58.object({
+  seq: z58.number().int().nonnegative().describe("Stable event position for pagination."),
+  history_version: z58.number().int().nonnegative().describe("Agent history generation after replacement."),
+  created_at: z58.iso.datetime().describe("When the event was recorded."),
+  idempotency_key: z58.string().min(1).optional().describe("Retry-stable event identity, when assigned."),
+  data: z58.record(z58.string(), z58.unknown()).describe("Bounded event data.")
 }).strict();
 var searchConversationEventsOutputSchema = juniorToolOutputSchema.extend({
-  conversation_id: z56.string().min(1),
-  events: z56.array(projectedEventSchema),
-  has_older: z56.boolean().describe("Whether matching older events exist."),
-  has_newer: z56.boolean().describe("Whether matching newer events exist."),
-  omitted_event_count: z56.number().int().nonnegative().optional().describe("Events omitted by the response byte limit.")
+  conversation_id: z58.string().min(1),
+  events: z58.array(projectedEventSchema),
+  has_older: z58.boolean().describe("Whether matching older events exist."),
+  has_newer: z58.boolean().describe("Whether matching newer events exist."),
+  omitted_event_count: z58.number().int().nonnegative().optional().describe("Events omitted by the response byte limit.")
 });
 function createSearchConversationEventsTool(context) {
   return zodTool({
@@ -12341,16 +12628,16 @@ function createSearchConversationEventsTool(context) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z56.object({
-      conversation_id: z56.string().trim().min(1).nullable().describe(
+    inputSchema: z58.object({
+      conversation_id: z58.string().trim().min(1).nullable().describe(
         "Conversation ID to search. Omit or null for the current conversation."
       ).optional(),
-      after_seq: z56.number().int().nonnegative().nullable().describe("Exclusive event sequence lower bound; returns ascending.").optional(),
-      before_seq: z56.number().int().nonnegative().nullable().describe("Exclusive event sequence upper bound.").optional(),
-      limit: z56.number().int().min(1).max(MAX_LIMIT).nullable().describe(
+      after_seq: z58.number().int().nonnegative().nullable().describe("Exclusive event sequence lower bound; returns ascending.").optional(),
+      before_seq: z58.number().int().nonnegative().nullable().describe("Exclusive event sequence upper bound.").optional(),
+      limit: z58.number().int().min(1).max(MAX_LIMIT).nullable().describe(
         `Maximum events. Default ${DEFAULT_LIMIT3}; max ${MAX_LIMIT}.`
       ).optional(),
-      types: z56.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
+      types: z58.array(knownEventTypeSchema).min(1).nullable().describe("Event types to include; omit for all types.").optional()
     }).strict(),
     outputSchema: searchConversationEventsOutputSchema,
     execute: async (input) => {
@@ -12596,10 +12883,10 @@ function stripReplacementHistoryField(value) {
 }
 
 // src/chat/tools/handoff/tool.ts
-import { z as z57 } from "zod";
+import { z as z59 } from "zod";
 var HANDOFF_TOOL_NAME = "handoff";
 function createHandoffTool(handoff) {
-  const profileSchema = z57.enum(handoff.profiles);
+  const profileSchema = z59.enum(handoff.profiles);
   const handoffResultSchema = juniorToolOutputSchema.extend({
     model_profile: modelProfileSchema
   });
@@ -12613,7 +12900,7 @@ function createHandoffTool(handoff) {
     },
     description: `Switch to another execution profile and continue the same task. Profiles: ${profileNames}. Call this as the only tool.`,
     executionMode: "sequential",
-    inputSchema: z57.object({
+    inputSchema: z59.object({
       profile: profileSchema.describe("Target execution profile")
     }).strict(),
     outputSchema: handoffResultSchema,
@@ -12634,7 +12921,7 @@ function createHandoffTool(handoff) {
 }
 
 // src/chat/tools/web/fetch-tool.ts
-import { z as z58 } from "zod";
+import { z as z60 } from "zod";
 
 // src/chat/tools/web/constants.ts
 var USER_AGENT = "junior-bot/0.1";
@@ -13077,9 +13364,9 @@ function createWebFetchTool(hooks, options = {}) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z58.object({
-      url: z58.string().min(1).describe("HTTP(S) URL to fetch."),
-      max_chars: z58.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
+    inputSchema: z60.object({
+      url: z60.string().min(1).describe("HTTP(S) URL to fetch."),
+      max_chars: z60.coerce.number().int().min(500).max(MAX_FETCH_CHARS).describe("Optional maximum number of extracted characters to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ url, max_chars }) => {
@@ -13124,7 +13411,7 @@ function createWebFetchTool(hooks, options = {}) {
 }
 
 // src/chat/tools/web/search.ts
-import { z as z59 } from "zod";
+import { z as z61 } from "zod";
 import { generateText } from "ai";
 import { createGatewayProvider } from "@ai-sdk/gateway";
 var SEARCH_TIMEOUT_MS = 6e4;
@@ -13166,9 +13453,9 @@ function createWebSearchTool(modelId, override) {
       openWorldHint: true,
       readOnlyHint: true
     },
-    inputSchema: z59.object({
-      query: z59.string().min(1).max(500).describe("Search query."),
-      max_results: z59.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
+    inputSchema: z61.object({
+      query: z61.string().min(1).max(500).describe("Search query."),
+      max_results: z61.coerce.number().int().min(1).max(MAX_RESULTS2).describe("Max results to return.").optional()
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async ({ query, max_results }) => {
@@ -13210,7 +13497,7 @@ function createWebSearchTool(modelId, override) {
 }
 
 // src/chat/tools/sandbox/write-file.ts
-import { z as z60 } from "zod";
+import { z as z62 } from "zod";
 function createWriteFileTool() {
   return zodTool({
     annotations: {
@@ -13221,9 +13508,9 @@ function createWriteFileTool() {
     },
     description: "Write UTF-8 content to a file in the sandbox workspace. Use for intentional file creation or deliberate full-file replacement after validation; use editFile instead for targeted changes to existing files. Do not use for exploratory analysis-only turns.",
     executionMode: "sequential",
-    inputSchema: z60.object({
-      path: z60.string().min(1).describe("Path to write in the sandbox workspace."),
-      content: z60.string().describe("UTF-8 file content to write.")
+    inputSchema: z62.object({
+      path: z62.string().min(1).describe("Path to write in the sandbox workspace."),
+      content: z62.string().describe("UTF-8 file content to write.")
     }),
     outputSchema: juniorToolOutputSchema,
     execute: async () => {
@@ -13300,6 +13587,18 @@ function createTools(availableSkills, hooks = {}, context, options = {}) {
       hooks.toolOverrides?.imageGenerate
     );
   }
+  if (context.attachmentStorage && context.conversationId) {
+    tools.publishImage = createPublishImageTool({
+      conversationId: context.conversationId,
+      db: getSqlExecutor(),
+      storage: context.attachmentStorage,
+      workspace: context.workspace
+    });
+    tools.unpublishImage = createUnpublishImageTool({
+      conversationId: context.conversationId,
+      db: getSqlExecutor()
+    });
+  }
   if (context.handoff) {
     tools.handoff = createHandoffTool(context.handoff);
   }
@@ -13946,7 +14245,7 @@ function handleToolExecutionError(error, toolName, toolCallId, shouldTrace, conv
 }
 
 // src/chat/tools/execute-tool.ts
-import { z as z61 } from "zod";
+import { z as z63 } from "zod";
 var EXECUTE_TOOL_NAME = "executeTool";
 function createExecuteToolTool() {
   return zodTool({
@@ -13958,11 +14257,11 @@ function createExecuteToolTool() {
     },
     description: "Execute any catalog tool by exact tool_name from searchTools or a tool-result execution hint. Put tool-specific parameters inside arguments.",
     executionMode: "sequential",
-    inputSchema: z61.object({
-      tool_name: z61.string().min(1).describe(
+    inputSchema: z63.object({
+      tool_name: z63.string().min(1).describe(
         "Exact catalog tool_name returned by searchTools or a tool-result execution hint."
       ),
-      arguments: z61.record(z61.string(), z61.unknown()).describe(
+      arguments: z63.record(z63.string(), z63.unknown()).describe(
         'Arguments matching the selected catalog tool schema, for example { "query": "..." }.'
       ).optional()
     }).strict(),
@@ -14002,7 +14301,7 @@ function planToolExposure(tools) {
 }
 
 // src/chat/tools/search-tools.ts
-import { z as z62 } from "zod";
+import { z as z64 } from "zod";
 var SEARCH_TOOLS_NAME = "searchTools";
 var DEFAULT_MAX_RESULTS2 = 5;
 var MAX_RESULTS3 = 20;
@@ -14047,29 +14346,29 @@ var SEARCH_STOP_WORDS = /* @__PURE__ */ new Set([
   "you",
   "your"
 ]);
-var searchToolsSourceSchema = z62.object({
-  id: z62.string(),
-  description: z62.string()
+var searchToolsSourceSchema = z64.object({
+  id: z64.string(),
+  description: z64.string()
 }).strict();
-var searchToolsToolSchema = z62.object({
-  tool_name: z62.string(),
-  description: z62.string(),
-  exposure: z62.enum(["direct", "deferred", "modelOnly", "hidden"]),
-  source: z62.string().optional(),
-  input_schema: z62.unknown(),
-  call_notes: z62.array(z62.string()),
-  annotations: z62.record(z62.string(), z62.unknown())
+var searchToolsToolSchema = z64.object({
+  tool_name: z64.string(),
+  description: z64.string(),
+  exposure: z64.enum(["direct", "deferred", "modelOnly", "hidden"]),
+  source: z64.string().optional(),
+  input_schema: z64.unknown(),
+  call_notes: z64.array(z64.string()),
+  annotations: z64.record(z64.string(), z64.unknown())
 }).strict();
 var searchToolsOutputSchema = juniorToolOutputSchema.extend({
-  query: z62.string().nullable(),
-  source: z62.string().nullable(),
-  sources: z62.array(searchToolsSourceSchema),
-  total_catalog_tools: z62.number().int().nonnegative(),
-  total_eligible_tools: z62.number().int().nonnegative(),
-  total_matches: z62.number().int().nonnegative(),
-  returned_tools: z62.number().int().nonnegative(),
-  execution_tool: z62.literal("executeTool"),
-  tools: z62.array(searchToolsToolSchema)
+  query: z64.string().nullable(),
+  source: z64.string().nullable(),
+  sources: z64.array(searchToolsSourceSchema),
+  total_catalog_tools: z64.number().int().nonnegative(),
+  total_eligible_tools: z64.number().int().nonnegative(),
+  total_matches: z64.number().int().nonnegative(),
+  returned_tools: z64.number().int().nonnegative(),
+  execution_tool: z64.literal("executeTool"),
+  tools: z64.array(searchToolsToolSchema)
 }).strict();
 function terms(value) {
   const chunks = value.match(/[\p{L}\p{N}]+/gu) ?? [];
@@ -14280,14 +14579,14 @@ function createSearchToolsTool(catalogTools) {
       openWorldHint: false,
       readOnlyHint: true
     },
-    inputSchema: z62.object({
-      query: z62.string().nullable().describe(
+    inputSchema: z64.object({
+      query: z64.string().nullable().describe(
         "Optional search terms describing the tool, owner, action, or arguments needed. Empty string lists catalog tools."
       ).optional(),
-      source: z62.string().nullable().describe(
+      source: z64.string().nullable().describe(
         "Optional source id to search within, such as a plugin source returned in sources."
       ).optional(),
-      max_results: z62.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
+      max_results: z64.number().int().min(1).max(MAX_RESULTS3).nullable().describe("Maximum matching catalog tool descriptors to return.").optional()
     }).strict(),
     outputSchema: searchToolsOutputSchema,
     privateTraceResult: (result) => ({
@@ -14733,7 +15032,7 @@ function createMcpAuthOrchestration(input) {
 }
 
 // src/chat/egress/plugin.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/chat/sandbox/egress/credentials.ts
 var HTTP_READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
@@ -15487,8 +15786,8 @@ async function executeCredentialedEgressRequest(input) {
 function credentialContextForPluginEgress(credentialContext) {
   return {
     credentials: credentialContext,
-    contextId: randomUUID3(),
-    egressId: `plugin-egress:${randomUUID3()}`,
+    contextId: randomUUID4(),
+    egressId: `plugin-egress:${randomUUID4()}`,
     expiresAtMs: Date.now() + 30 * 60 * 1e3
   };
 }
@@ -15546,7 +15845,7 @@ function createPluginEgress(deps) {
 }
 
 // src/chat/services/guardian-action-review.ts
-import { z as z63 } from "zod";
+import { z as z65 } from "zod";
 
 // src/chat/services/guardian-action-policy.ts
 var GUARDIAN_ACTION_POLICY = `You are judging one planned Junior agent action.
@@ -15614,17 +15913,17 @@ Assess the exact action's intrinsic risk and whether the user's intent authorize
 - Keep the reason to one concise, specific sentence grounded in the main risk or authorization fact. For ask, name the exact action, target, and material side effects the user must confirm.`;
 
 // src/chat/services/guardian-action-review.ts
-var guardianDecisionSchema = z63.object({
-  decision: z63.enum(["allow", "ask", "deny"]),
-  reason: z63.string().trim().min(1).max(500),
-  riskLevel: z63.enum(["low", "medium", "high", "critical"]),
-  userAuthorization: z63.enum(["high", "medium", "low", "unknown"])
+var guardianDecisionSchema = z65.object({
+  decision: z65.enum(["allow", "ask", "deny"]),
+  reason: z65.string().trim().min(1).max(500),
+  riskLevel: z65.enum(["low", "medium", "high", "critical"]),
+  userAuthorization: z65.enum(["high", "medium", "low", "unknown"])
 }).strict();
 var GUARDIAN_REVIEW_TIMEOUT_MS = 6e4;
 var GUARDIAN_REVIEW_MAX_TOKENS = 2e3;
 var MAX_PROPOSAL_CHARS = 192e3;
 function guardianPrompt(proposal) {
-  const proposalJson = JSON.stringify(z63.json().parse(proposal), null, 2);
+  const proposalJson = JSON.stringify(z65.json().parse(proposal), null, 2);
   if (proposalJson.length > MAX_PROPOSAL_CHARS) {
     throw new Error(
       `Guardian action proposal exceeds ${MAX_PROPOSAL_CHARS} characters.`
@@ -18220,6 +18519,9 @@ export {
   listThreadReplies,
   renderBlockText,
   renderAttachmentText,
+  readPublicArtifact,
+  publicArtifactHeaders,
+  unpublishedArtifactHeaders,
   latestReportedProgress,
   executeCredentialedEgressRequest,
   createContextCompactor,