@caspian2026/agent-sdk 0.0.2

package/dist/chunk-162ewhvy.js

@@ -0,0 +1,869 @@
+// @bun
+import {
+  init_slashCommandParsing,
+  parseSlashCommand
+} from "./chunk-rn0v1hk8.js";
+import {
+  NO_CONTENT_MESSAGE,
+  addSessionHook,
+  buildPluginCommandTelemetryFields,
+  buildPostCompactMessages,
+  builtInCommandNames,
+  createAgentId,
+  createAttachmentMessage,
+  createCommandInputMessage,
+  createSyntheticUserCaveatMessage,
+  createSystemMessage,
+  createUserInterruptionMessage,
+  createUserMessage,
+  extractResultText,
+  findCommand,
+  formatCommandInputTags,
+  getAgentContext,
+  getAssistantMessageContentLength,
+  getAttachmentMessages,
+  getCommand,
+  getCommandName,
+  getDumpPromptsPath,
+  hasCommand,
+  hasPermissionsToUseTool,
+  init_UI,
+  init_abortController,
+  init_agentContext,
+  init_attachments,
+  init_commands1 as init_commands,
+  init_compact,
+  init_dumpPrompts,
+  init_events,
+  init_forkedAgent,
+  init_fullscreen,
+  init_generators,
+  init_messageQueueManager,
+  init_messages,
+  init_messages1 as init_messages2,
+  init_microCompact,
+  init_permissionSetup,
+  init_permissions,
+  init_pluginIdentifier,
+  init_pluginOnlyPolicy,
+  init_pluginTelemetry,
+  init_runAgent,
+  init_sessionHooks,
+  init_skillUsageTracking,
+  init_tokens,
+  init_uuid,
+  isCompactBoundaryMessage,
+  isFullscreenEnvEnabled,
+  isOfficialMarketplaceName,
+  isRestrictedToPluginOnly,
+  isSourceAdminTrusted,
+  isSystemLocalCommandMessage,
+  logOTelEvent,
+  normalizeMessages,
+  parsePluginIdentifier,
+  parseToolListFromCLI,
+  prepareForkedCommandContext,
+  prepareUserContent,
+  recordSkillUsage,
+  redactIfDisabled,
+  removeSessionHook,
+  renderToolUseProgressMessage,
+  resetMicrocompactState,
+  runAgent,
+  toArray
+} from "./chunk-vzgkedm9.js";
+import"./chunk-46hdszda.js";
+import"./chunk-hwfknpxv.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-jzthz1bx.js";
+import"./chunk-1gx78081.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-68w91pzt.js";
+import"./chunk-s4cb0bcb.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-nebezy1d.js";
+import"./chunk-wayfjcwt.js";
+import"./chunk-kbm69rtz.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-nxgsnh2y.js";
+import"./chunk-68ffk5qa.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-bmbq6nt1.js";
+import"./chunk-15sfg4bs.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-b0qptb1k.js";
+import"./chunk-m87bhhqv.js";
+import"./chunk-j3zhb8vv.js";
+import"./chunk-b2fd462a.js";
+import"./chunk-c11swzas.js";
+import"./chunk-chsyvavm.js";
+import"./chunk-5rv9c8yd.js";
+import {
+  HOOK_EVENTS,
+  getDisplayPath,
+  init_agentSdkTypes,
+  init_file,
+  init_workloadContext
+} from "./chunk-tp2jxmcx.js";
+import"./chunk-z19sd3bt.js";
+import"./chunk-1ax1znzj.js";
+import"./chunk-wha6v7za.js";
+import"./chunk-6nsd9606.js";
+import"./chunk-xp61y5ba.js";
+import"./chunk-64c1avct.js";
+import {
+  init_sleep
+} from "./chunk-8g5pe1gr.js";
+import"./chunk-4cp6193g.js";
+import"./chunk-8g747a8x.js";
+import"./chunk-d7886r6a.js";
+import"./chunk-yvtzznds.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-2f21meep.js";
+import"./chunk-nrtksr2p.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-s3hsqf80.js";
+import"./chunk-yyf72f78.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-c7jwbe76.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-7sgtxrsc.js";
+import"./chunk-0xjaqda8.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-x8d2ehd7.js";
+import"./chunk-15m49c67.js";
+import"./chunk-tdbz9gbm.js";
+import"./chunk-0awwmrwr.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-70eey1nh.js";
+import {
+  COMMAND_MESSAGE_TAG,
+  COMMAND_NAME_TAG,
+  init_log,
+  init_xml,
+  logError
+} from "./chunk-1nk93fqz.js";
+import"./chunk-s8kj6ajy.js";
+import"./chunk-eenq3avg.js";
+import"./chunk-7mqab3z7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  AbortError,
+  MalformedCommandError,
+  getFsImplementation,
+  init_debug,
+  init_errors,
+  init_fsOperations,
+  logForDebugging
+} from "./chunk-phd1qfpc.js";
+import"./chunk-fbv4apne.js";
+import {
+  init_envUtils
+} from "./chunk-jaaxk89e.js";
+import {
+  addInvokedSkill,
+  getSessionId,
+  init_state,
+  setPromptId
+} from "./chunk-k8vp0atq.js";
+import"./chunk-vf612n57.js";
+import"./chunk-07069jq1.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-55raexh7.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-b0kf00ff.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/hooks/registerSkillHooks.ts
+function registerSkillHooks(setAppState, sessionId, hooks, skillName, skillRoot) {
+  let registeredCount = 0;
+  for (const eventName of HOOK_EVENTS) {
+    const matchers = hooks[eventName];
+    if (!matchers)
+      continue;
+    for (const matcher of matchers) {
+      for (const hook of matcher.hooks) {
+        const onHookSuccess = hook.once ? () => {
+          logForDebugging(`Removing one-shot hook for event ${eventName} in skill '${skillName}'`);
+          removeSessionHook(setAppState, sessionId, eventName, hook);
+        } : undefined;
+        addSessionHook(setAppState, sessionId, eventName, matcher.matcher || "", hook, onHookSuccess, skillRoot);
+        registeredCount++;
+      }
+    }
+  }
+  if (registeredCount > 0) {
+    logForDebugging(`Registered ${registeredCount} hooks from skill '${skillName}'`);
+  }
+}
+var init_registerSkillHooks = __esm(() => {
+  init_agentSdkTypes();
+  init_debug();
+  init_sessionHooks();
+});
+
+// src/utils/processUserInput/processSlashCommand.tsx
+import { randomUUID } from "crypto";
+async function executeForkedSlashCommand(command, args, context, precedingInputBlocks, setToolJSX, canUseTool) {
+  const agentId = createAgentId();
+  const pluginMarketplace = command.pluginInfo ? parsePluginIdentifier(command.pluginInfo.repository).marketplace : undefined;
+  logEvent("tengu_slash_command_forked", {
+    command_name: command.name,
+    invocation_trigger: "user-slash",
+    ...command.pluginInfo && {
+      _PROTO_plugin_name: command.pluginInfo.pluginManifest.name,
+      ...pluginMarketplace && {
+        _PROTO_marketplace_name: pluginMarketplace
+      },
+      ...buildPluginCommandTelemetryFields(command.pluginInfo)
+    }
+  });
+  const { skillContent, modifiedGetAppState, baseAgent, promptMessages } = await prepareForkedCommandContext(command, args, context);
+  const agentDefinition = command.effort !== undefined ? { ...baseAgent, effort: command.effort } : baseAgent;
+  logForDebugging(`Executing forked slash command /${command.name} with agent ${agentDefinition.agentType}`);
+  if (false) {}
+  const agentMessages = [];
+  const progressMessages = [];
+  const parentToolUseID = `forked-command-${command.name}`;
+  let toolUseCounter = 0;
+  const createProgressMessage = (message) => {
+    toolUseCounter++;
+    return {
+      type: "progress",
+      data: {
+        message,
+        type: "agent_progress",
+        prompt: skillContent,
+        agentId
+      },
+      parentToolUseID,
+      toolUseID: `${parentToolUseID}-${toolUseCounter}`,
+      timestamp: new Date().toISOString(),
+      uuid: randomUUID()
+    };
+  };
+  const updateProgress = () => {
+    setToolJSX({
+      jsx: renderToolUseProgressMessage(progressMessages, {
+        tools: context.options.tools,
+        verbose: false
+      }),
+      shouldHidePromptInput: false,
+      shouldContinueAnimation: true,
+      showSpinner: true
+    });
+  };
+  updateProgress();
+  try {
+    for await (const message of runAgent({
+      agentDefinition,
+      promptMessages,
+      toolUseContext: {
+        ...context,
+        getAppState: modifiedGetAppState
+      },
+      canUseTool,
+      isAsync: false,
+      querySource: "agent:custom",
+      model: command.model,
+      availableTools: context.options.tools
+    })) {
+      agentMessages.push(message);
+      const normalizedNew = normalizeMessages([message]);
+      if (message.type === "assistant") {
+        const contentLength = getAssistantMessageContentLength(message);
+        if (contentLength > 0) {
+          context.setResponseLength((len) => len + contentLength);
+        }
+        const normalizedMsg = normalizedNew[0];
+        if (normalizedMsg && normalizedMsg.type === "assistant") {
+          progressMessages.push(createProgressMessage(message));
+          updateProgress();
+        }
+      }
+      if (message.type === "user") {
+        const normalizedMsg = normalizedNew[0];
+        if (normalizedMsg && normalizedMsg.type === "user") {
+          progressMessages.push(createProgressMessage(normalizedMsg));
+          updateProgress();
+        }
+      }
+    }
+  } finally {
+    setToolJSX(null);
+  }
+  let resultText = extractResultText(agentMessages, "Command completed");
+  logForDebugging(`Forked slash command /${command.name} completed with agent ${agentId}`);
+  if (process.env.USER_TYPE === "ant") {
+    resultText = `[ANT-ONLY] API calls: ${getDisplayPath(getDumpPromptsPath(agentId))}
+${resultText}`;
+  }
+  const messages = [
+    createUserMessage({
+      content: prepareUserContent({
+        inputString: `/${getCommandName(command)} ${args}`.trim(),
+        precedingInputBlocks
+      })
+    }),
+    createUserMessage({
+      content: `<local-command-stdout>
+${resultText}
+</local-command-stdout>`
+    })
+  ];
+  return {
+    messages,
+    shouldQuery: false,
+    command,
+    resultText
+  };
+}
+function looksLikeCommand(commandName) {
+  return !/[^a-zA-Z0-9:\-_]/.test(commandName);
+}
+async function processSlashCommand(inputString, precedingInputBlocks, imageContentBlocks, attachmentMessages, context, setToolJSX, uuid, isAlreadyProcessing, canUseTool) {
+  const parsed = parseSlashCommand(inputString);
+  if (!parsed) {
+    logEvent("tengu_input_slash_missing", {});
+    const errorMessage = "Commands are in the form `/command [args]`";
+    return {
+      messages: [
+        createSyntheticUserCaveatMessage(),
+        ...attachmentMessages,
+        createUserMessage({
+          content: prepareUserContent({
+            inputString: errorMessage,
+            precedingInputBlocks
+          })
+        })
+      ],
+      shouldQuery: false,
+      resultText: errorMessage
+    };
+  }
+  const { commandName, args: parsedArgs, isMcp } = parsed;
+  const sanitizedCommandName = isMcp ? "mcp" : !builtInCommandNames().has(commandName) ? "custom" : commandName;
+  if (!hasCommand(commandName, context.options.commands)) {
+    let isFilePath = false;
+    try {
+      await getFsImplementation().stat(`/${commandName}`);
+      isFilePath = true;
+    } catch {}
+    if (looksLikeCommand(commandName) && !isFilePath) {
+      logEvent("tengu_input_slash_invalid", {
+        input: commandName
+      });
+      const unknownMessage = `Unknown skill: ${commandName}`;
+      return {
+        messages: [
+          createSyntheticUserCaveatMessage(),
+          ...attachmentMessages,
+          createUserMessage({
+            content: prepareUserContent({
+              inputString: unknownMessage,
+              precedingInputBlocks
+            })
+          }),
+          ...parsedArgs ? [
+            createSystemMessage(`Args from unknown skill: ${parsedArgs}`, "warning")
+          ] : []
+        ],
+        shouldQuery: false,
+        resultText: unknownMessage
+      };
+    }
+    const promptId = randomUUID();
+    setPromptId(promptId);
+    logEvent("tengu_input_prompt", {});
+    logOTelEvent("user_prompt", {
+      prompt_length: String(inputString.length),
+      prompt: redactIfDisabled(inputString),
+      "prompt.id": promptId
+    });
+    return {
+      messages: [
+        createUserMessage({
+          content: prepareUserContent({ inputString, precedingInputBlocks }),
+          uuid
+        }),
+        ...attachmentMessages
+      ],
+      shouldQuery: true
+    };
+  }
+  const {
+    messages: newMessages,
+    shouldQuery: messageShouldQuery,
+    allowedTools,
+    model,
+    effort,
+    command: returnedCommand,
+    resultText,
+    nextInput,
+    submitNextInput
+  } = await getMessagesForSlashCommand(commandName, parsedArgs, setToolJSX, context, precedingInputBlocks, imageContentBlocks, isAlreadyProcessing, canUseTool, uuid);
+  if (newMessages.length === 0) {
+    const eventData2 = {
+      input: sanitizedCommandName
+    };
+    if (returnedCommand.type === "prompt" && returnedCommand.pluginInfo) {
+      const { pluginManifest, repository } = returnedCommand.pluginInfo;
+      const { marketplace } = parsePluginIdentifier(repository);
+      const isOfficial = isOfficialMarketplaceName(marketplace);
+      eventData2._PROTO_plugin_name = pluginManifest.name;
+      if (marketplace) {
+        eventData2._PROTO_marketplace_name = marketplace;
+      }
+      eventData2.plugin_repository = isOfficial ? repository : "third-party";
+      eventData2.plugin_name = isOfficial ? pluginManifest.name : "third-party";
+      if (isOfficial && pluginManifest.version) {
+        eventData2.plugin_version = pluginManifest.version;
+      }
+      Object.assign(eventData2, buildPluginCommandTelemetryFields(returnedCommand.pluginInfo));
+    }
+    logEvent("tengu_input_command", {
+      ...eventData2,
+      invocation_trigger: "user-slash",
+      ...process.env.USER_TYPE === "ant" && {
+        skill_name: commandName,
+        ...returnedCommand.type === "prompt" && {
+          skill_source: returnedCommand.source
+        },
+        ...returnedCommand.loadedFrom && {
+          skill_loaded_from: returnedCommand.loadedFrom
+        },
+        ...returnedCommand.kind && {
+          skill_kind: returnedCommand.kind
+        }
+      }
+    });
+    return {
+      messages: [],
+      shouldQuery: false,
+      model,
+      nextInput,
+      submitNextInput
+    };
+  }
+  if (newMessages.length === 2 && newMessages[1].type === "user" && typeof newMessages[1].message.content === "string" && newMessages[1].message.content.startsWith("Unknown command:")) {
+    const looksLikeFilePath = inputString.startsWith("/var") || inputString.startsWith("/tmp") || inputString.startsWith("/private");
+    if (!looksLikeFilePath) {
+      logEvent("tengu_input_slash_invalid", {
+        input: commandName
+      });
+    }
+    return {
+      messages: [createSyntheticUserCaveatMessage(), ...newMessages],
+      shouldQuery: messageShouldQuery,
+      allowedTools,
+      model
+    };
+  }
+  const eventData = {
+    input: sanitizedCommandName
+  };
+  if (returnedCommand.type === "prompt" && returnedCommand.pluginInfo) {
+    const { pluginManifest, repository } = returnedCommand.pluginInfo;
+    const { marketplace } = parsePluginIdentifier(repository);
+    const isOfficial = isOfficialMarketplaceName(marketplace);
+    eventData._PROTO_plugin_name = pluginManifest.name;
+    if (marketplace) {
+      eventData._PROTO_marketplace_name = marketplace;
+    }
+    eventData.plugin_repository = isOfficial ? repository : "third-party";
+    eventData.plugin_name = isOfficial ? pluginManifest.name : "third-party";
+    if (isOfficial && pluginManifest.version) {
+      eventData.plugin_version = pluginManifest.version;
+    }
+    Object.assign(eventData, buildPluginCommandTelemetryFields(returnedCommand.pluginInfo));
+  }
+  logEvent("tengu_input_command", {
+    ...eventData,
+    invocation_trigger: "user-slash",
+    ...process.env.USER_TYPE === "ant" && {
+      skill_name: commandName,
+      ...returnedCommand.type === "prompt" && {
+        skill_source: returnedCommand.source
+      },
+      ...returnedCommand.loadedFrom && {
+        skill_loaded_from: returnedCommand.loadedFrom
+      },
+      ...returnedCommand.kind && {
+        skill_kind: returnedCommand.kind
+      }
+    }
+  });
+  const isCompactResult = newMessages.length > 0 && newMessages[0] && isCompactBoundaryMessage(newMessages[0]);
+  return {
+    messages: messageShouldQuery || newMessages.every(isSystemLocalCommandMessage) || isCompactResult ? newMessages : [createSyntheticUserCaveatMessage(), ...newMessages],
+    shouldQuery: messageShouldQuery,
+    allowedTools,
+    model,
+    effort,
+    resultText,
+    nextInput,
+    submitNextInput
+  };
+}
+async function getMessagesForSlashCommand(commandName, args, setToolJSX, context, precedingInputBlocks, imageContentBlocks, _isAlreadyProcessing, canUseTool, uuid) {
+  const command = getCommand(commandName, context.options.commands);
+  if (command.type === "prompt" && command.userInvocable !== false) {
+    recordSkillUsage(commandName);
+  }
+  if (command.userInvocable === false) {
+    return {
+      messages: [
+        createUserMessage({
+          content: prepareUserContent({
+            inputString: `/${commandName}`,
+            precedingInputBlocks
+          })
+        }),
+        createUserMessage({
+          content: `This skill can only be invoked by Claude, not directly by users. Ask Claude to use the "${commandName}" skill for you.`
+        })
+      ],
+      shouldQuery: false,
+      command
+    };
+  }
+  try {
+    switch (command.type) {
+      case "local-jsx": {
+        return new Promise((resolve) => {
+          let doneWasCalled = false;
+          const onDone = (result, options) => {
+            doneWasCalled = true;
+            if (options?.display === "skip") {
+              resolve({
+                messages: [],
+                shouldQuery: false,
+                command,
+                nextInput: options?.nextInput,
+                submitNextInput: options?.submitNextInput
+              });
+              return;
+            }
+            const metaMessages = (options?.metaMessages ?? []).map((content) => createUserMessage({ content, isMeta: true }));
+            const skipTranscript = isFullscreenEnvEnabled() && typeof result === "string" && result.endsWith(" dismissed");
+            resolve({
+              messages: options?.display === "system" ? skipTranscript ? metaMessages : [
+                createCommandInputMessage(formatCommandInput(command, args)),
+                createCommandInputMessage(`<local-command-stdout>${result}</local-command-stdout>`),
+                ...metaMessages
+              ] : [
+                createUserMessage({
+                  content: prepareUserContent({
+                    inputString: formatCommandInput(command, args),
+                    precedingInputBlocks
+                  })
+                }),
+                result ? createUserMessage({
+                  content: `<local-command-stdout>${result}</local-command-stdout>`
+                }) : createUserMessage({
+                  content: `<local-command-stdout>${NO_CONTENT_MESSAGE}</local-command-stdout>`
+                }),
+                ...metaMessages
+              ],
+              shouldQuery: options?.shouldQuery ?? false,
+              command,
+              nextInput: options?.nextInput,
+              submitNextInput: options?.submitNextInput
+            });
+          };
+          command.load().then((mod) => mod.call(onDone, { ...context, canUseTool }, args)).then((jsx) => {
+            if (jsx == null)
+              return;
+            if (context.options.isNonInteractiveSession) {
+              resolve({
+                messages: [],
+                shouldQuery: false,
+                command
+              });
+              return;
+            }
+            if (doneWasCalled)
+              return;
+            setToolJSX({
+              jsx,
+              shouldHidePromptInput: true,
+              showSpinner: false,
+              isLocalJSXCommand: true,
+              isImmediate: command.immediate === true
+            });
+          }).catch((e) => {
+            logError(e);
+            if (doneWasCalled)
+              return;
+            doneWasCalled = true;
+            setToolJSX({
+              jsx: null,
+              shouldHidePromptInput: false,
+              clearLocalJSX: true
+            });
+            resolve({ messages: [], shouldQuery: false, command });
+          });
+        });
+      }
+      case "local": {
+        const displayArgs = command.isSensitive && args.trim() ? "***" : args;
+        const userMessage = createUserMessage({
+          content: prepareUserContent({
+            inputString: formatCommandInput(command, displayArgs),
+            precedingInputBlocks
+          })
+        });
+        try {
+          const syntheticCaveatMessage = createSyntheticUserCaveatMessage();
+          const mod = await command.load();
+          const result = await mod.call(args, context);
+          if (result.type === "skip") {
+            return {
+              messages: [],
+              shouldQuery: false,
+              command
+            };
+          }
+          if (result.type === "compact") {
+            const slashCommandMessages = [
+              syntheticCaveatMessage,
+              userMessage,
+              ...result.displayText ? [
+                createUserMessage({
+                  content: `<local-command-stdout>${result.displayText}</local-command-stdout>`,
+                  timestamp: new Date(Date.now() + 100).toISOString()
+                })
+              ] : []
+            ];
+            const compactionResultWithSlashMessages = {
+              ...result.compactionResult,
+              messagesToKeep: [
+                ...result.compactionResult.messagesToKeep ?? [],
+                ...slashCommandMessages
+              ]
+            };
+            resetMicrocompactState();
+            return {
+              messages: buildPostCompactMessages(compactionResultWithSlashMessages),
+              shouldQuery: false,
+              command
+            };
+          }
+          return {
+            messages: [
+              userMessage,
+              createCommandInputMessage(`<local-command-stdout>${result.value}</local-command-stdout>`)
+            ],
+            shouldQuery: false,
+            command,
+            resultText: result.value
+          };
+        } catch (e) {
+          logError(e);
+          return {
+            messages: [
+              userMessage,
+              createCommandInputMessage(`<local-command-stderr>${String(e)}</local-command-stderr>`)
+            ],
+            shouldQuery: false,
+            command
+          };
+        }
+      }
+      case "prompt": {
+        try {
+          if (command.context === "fork") {
+            return await executeForkedSlashCommand(command, args, context, precedingInputBlocks, setToolJSX, canUseTool ?? hasPermissionsToUseTool);
+          }
+          return await getMessagesForPromptSlashCommand(command, args, context, precedingInputBlocks, imageContentBlocks, uuid);
+        } catch (e) {
+          if (e instanceof AbortError) {
+            return {
+              messages: [
+                createUserMessage({
+                  content: prepareUserContent({
+                    inputString: formatCommandInput(command, args),
+                    precedingInputBlocks
+                  })
+                }),
+                createUserInterruptionMessage({ toolUse: false })
+              ],
+              shouldQuery: false,
+              command
+            };
+          }
+          return {
+            messages: [
+              createUserMessage({
+                content: prepareUserContent({
+                  inputString: formatCommandInput(command, args),
+                  precedingInputBlocks
+                })
+              }),
+              createUserMessage({
+                content: `<local-command-stderr>${String(e)}</local-command-stderr>`
+              })
+            ],
+            shouldQuery: false,
+            command
+          };
+        }
+      }
+    }
+  } catch (e) {
+    if (e instanceof MalformedCommandError) {
+      return {
+        messages: [
+          createUserMessage({
+            content: prepareUserContent({
+              inputString: e.message,
+              precedingInputBlocks
+            })
+          })
+        ],
+        shouldQuery: false,
+        command
+      };
+    }
+    throw e;
+  }
+}
+function formatCommandInput(command, args) {
+  return formatCommandInputTags(getCommandName(command), args);
+}
+function formatSkillLoadingMetadata(skillName, _progressMessage = "loading") {
+  return [
+    `<${COMMAND_MESSAGE_TAG}>${skillName}</${COMMAND_MESSAGE_TAG}>`,
+    `<${COMMAND_NAME_TAG}>${skillName}</${COMMAND_NAME_TAG}>`,
+    `<skill-format>true</skill-format>`
+  ].join(`
+`);
+}
+function formatSlashCommandLoadingMetadata(commandName, args) {
+  return [
+    `<${COMMAND_MESSAGE_TAG}>${commandName}</${COMMAND_MESSAGE_TAG}>`,
+    `<${COMMAND_NAME_TAG}>/${commandName}</${COMMAND_NAME_TAG}>`,
+    args ? `<command-args>${args}</command-args>` : null
+  ].filter(Boolean).join(`
+`);
+}
+function formatCommandLoadingMetadata(command, args) {
+  if (command.userInvocable !== false) {
+    return formatSlashCommandLoadingMetadata(command.name, args);
+  }
+  if (command.loadedFrom === "skills" || command.loadedFrom === "plugin" || command.loadedFrom === "mcp") {
+    return formatSkillLoadingMetadata(command.name, command.progressMessage);
+  }
+  return formatSlashCommandLoadingMetadata(command.name, args);
+}
+async function processPromptSlashCommand(commandName, args, commands, context, imageContentBlocks = []) {
+  const command = findCommand(commandName, commands);
+  if (!command) {
+    throw new MalformedCommandError(`Unknown command: ${commandName}`);
+  }
+  if (command.type !== "prompt") {
+    throw new Error(`Unexpected ${command.type} command. Expected 'prompt' command. Use /${commandName} directly in the main conversation.`);
+  }
+  return getMessagesForPromptSlashCommand(command, args, context, [], imageContentBlocks);
+}
+async function getMessagesForPromptSlashCommand(command, args, context, precedingInputBlocks = [], imageContentBlocks = [], uuid) {
+  if (false) {}
+  const result = await command.getPromptForCommand(args, context);
+  const hooksAllowedForThisSkill = !isRestrictedToPluginOnly("hooks") || isSourceAdminTrusted(command.source);
+  if (command.hooks && hooksAllowedForThisSkill) {
+    const sessionId = getSessionId();
+    registerSkillHooks(context.setAppState, sessionId, command.hooks, command.name, command.type === "prompt" ? command.skillRoot : undefined);
+  }
+  const skillPath = command.source ? `${command.source}:${command.name}` : command.name;
+  const skillContent = result.filter((b) => b.type === "text").map((b) => b.text).join(`
+
+`);
+  addInvokedSkill(command.name, skillPath, skillContent, getAgentContext()?.agentId ?? null);
+  const metadata = formatCommandLoadingMetadata(command, args);
+  const additionalAllowedTools = parseToolListFromCLI(command.allowedTools ?? []);
+  const mainMessageContent = imageContentBlocks.length > 0 || precedingInputBlocks.length > 0 ? [...imageContentBlocks, ...precedingInputBlocks, ...result] : result;
+  const attachmentMessages = await toArray(getAttachmentMessages(result.filter((block) => block.type === "text").map((block) => block.text).join(" "), context, null, [], context.messages, "repl_main_thread", { skipSkillDiscovery: true }));
+  const messages = [
+    createUserMessage({
+      content: metadata,
+      uuid
+    }),
+    createUserMessage({
+      content: mainMessageContent,
+      isMeta: true
+    }),
+    ...attachmentMessages,
+    createAttachmentMessage({
+      type: "command_permissions",
+      allowedTools: additionalAllowedTools,
+      model: command.model
+    })
+  ];
+  return {
+    messages,
+    shouldQuery: true,
+    allowedTools: additionalAllowedTools,
+    model: command.model,
+    effort: command.effort,
+    command
+  };
+}
+var init_processSlashCommand = __esm(() => {
+  init_state();
+  init_commands();
+  init_messages();
+  init_state();
+  init_xml();
+  init_analytics();
+  init_dumpPrompts();
+  init_compact();
+  init_microCompact();
+  init_runAgent();
+  init_UI();
+  init_abortController();
+  init_agentContext();
+  init_attachments();
+  init_debug();
+  init_envUtils();
+  init_errors();
+  init_file();
+  init_forkedAgent();
+  init_fsOperations();
+  init_fullscreen();
+  init_generators();
+  init_registerSkillHooks();
+  init_log();
+  init_messageQueueManager();
+  init_messages2();
+  init_permissionSetup();
+  init_permissions();
+  init_pluginIdentifier();
+  init_pluginOnlyPolicy();
+  init_slashCommandParsing();
+  init_sleep();
+  init_skillUsageTracking();
+  init_events();
+  init_pluginTelemetry();
+  init_tokens();
+  init_uuid();
+  init_workloadContext();
+});
+init_processSlashCommand();
+
+export {
+  processSlashCommand,
+  processPromptSlashCommand,
+  looksLikeCommand,
+  formatSkillLoadingMetadata
+};