@octavus/core 2.19.0 → 2.20.0

package/dist/index.cjs

@@ -0,0 +1,883 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AppError: () => AppError,
+  ConflictError: () => ConflictError,
+  ForbiddenError: () => ForbiddenError,
+  MAIN_THREAD: () => MAIN_THREAD,
+  NotFoundError: () => NotFoundError,
+  OCTAVUS_INTERNAL_PREFIX: () => OCTAVUS_INTERNAL_PREFIX,
+  OCTAVUS_INTERNAL_TOOLS: () => OCTAVUS_INTERNAL_TOOLS,
+  OCTAVUS_REFERENCE_TOOLS: () => OCTAVUS_REFERENCE_TOOLS,
+  OCTAVUS_SKILL_TOOLS: () => OCTAVUS_SKILL_TOOLS,
+  OctavusError: () => OctavusError,
+  ValidationError: () => ValidationError,
+  chatMessageSchema: () => chatMessageSchema,
+  createApiErrorEvent: () => createApiErrorEvent,
+  createErrorEvent: () => createErrorEvent,
+  createInternalErrorEvent: () => createInternalErrorEvent,
+  errorToStreamEvent: () => errorToStreamEvent,
+  fileReferenceSchema: () => fileReferenceSchema,
+  generateId: () => generateId,
+  getSkillSlugFromToolCall: () => getSkillSlugFromToolCall,
+  isAbortError: () => isAbortError,
+  isAuthenticationError: () => isAuthenticationError,
+  isFileReference: () => isFileReference,
+  isFileReferenceArray: () => isFileReferenceArray,
+  isMainThread: () => isMainThread,
+  isOctavusInternalTool: () => isOctavusInternalTool,
+  isOctavusReferenceTool: () => isOctavusReferenceTool,
+  isOctavusSkillTool: () => isOctavusSkillTool,
+  isOtherThread: () => isOtherThread,
+  isProviderError: () => isProviderError,
+  isRateLimitError: () => isRateLimitError,
+  isRetryableError: () => isRetryableError,
+  isToolError: () => isToolError,
+  isValidationError: () => isValidationError,
+  resolveThread: () => resolveThread,
+  safeParseStreamEvent: () => safeParseStreamEvent,
+  safeParseUIMessage: () => safeParseUIMessage,
+  safeParseUIMessages: () => safeParseUIMessages,
+  threadForPart: () => threadForPart,
+  toolResultSchema: () => toolResultSchema,
+  uiMessagePartSchema: () => uiMessagePartSchema,
+  uiMessageSchema: () => uiMessageSchema,
+  uiWorkerPartSchema: () => uiWorkerPartSchema,
+  uiWorkerStatusSchema: () => uiWorkerStatusSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var AppError = class extends Error {
+  constructor(message, code, statusCode = 500) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "AppError";
+  }
+};
+var NotFoundError = class extends AppError {
+  constructor(resource, id) {
+    super(`${resource} not found: ${id}`, "NOT_FOUND", 404);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends AppError {
+  constructor(message, issues) {
+    super(message, "VALIDATION_ERROR", 400);
+    this.issues = issues;
+    this.name = "ValidationError";
+  }
+};
+var ConflictError = class extends AppError {
+  constructor(resource, identifier) {
+    super(`${resource} already exists: ${identifier}`, "CONFLICT", 409);
+    this.name = "ConflictError";
+  }
+};
+var ForbiddenError = class extends AppError {
+  constructor(message = "Access denied") {
+    super(message, "FORBIDDEN", 403);
+    this.name = "ForbiddenError";
+  }
+};
+
+// src/errors/octavus-error.ts
+var MARKER_KEY = "octavus.error";
+var OctavusError = class extends Error {
+  /** @internal Marker for cross-version instanceof checks */
+  __octavusErrorMarker = MARKER_KEY;
+  /** Error type classification */
+  errorType;
+  /** Where the error originated */
+  source;
+  /** Whether automatic retry is possible */
+  retryable;
+  /** Suggested retry delay in seconds (from provider headers) */
+  retryAfter;
+  /** Machine-readable error code */
+  code;
+  /** Provider details (when source === 'provider') */
+  provider;
+  /** Tool details (when source === 'tool') */
+  tool;
+  constructor(options) {
+    super(options.message);
+    this.name = "OctavusError";
+    this.errorType = options.errorType;
+    this.source = options.source;
+    this.retryable = options.retryable ?? false;
+    this.retryAfter = options.retryAfter;
+    this.code = options.code;
+    this.provider = options.provider;
+    this.tool = options.tool;
+    if (options.cause instanceof Error && options.cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${options.cause.stack}`;
+    }
+  }
+  /**
+   * Check if an unknown value is an OctavusError.
+   * Works reliably across package versions using marker property.
+   */
+  static isInstance(error) {
+    return typeof error === "object" && error !== null && "__octavusErrorMarker" in error && error.__octavusErrorMarker === MARKER_KEY;
+  }
+  /**
+   * Convert error to plain object for serialization.
+   * Used for streaming error events.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      errorType: this.errorType,
+      source: this.source,
+      retryable: this.retryable,
+      retryAfter: this.retryAfter,
+      code: this.code,
+      provider: this.provider,
+      tool: this.tool
+    };
+  }
+};
+function isRateLimitError(error) {
+  return OctavusError.isInstance(error) && (error.errorType === "rate_limit_error" || error.errorType === "quota_exceeded_error");
+}
+function isAuthenticationError(error) {
+  return OctavusError.isInstance(error) && (error.errorType === "authentication_error" || error.errorType === "permission_error");
+}
+function isProviderError(error) {
+  return OctavusError.isInstance(error) && error.source === "provider";
+}
+function isToolError(error) {
+  return OctavusError.isInstance(error) && (error.source === "tool" || error.errorType === "tool_error");
+}
+function isRetryableError(error) {
+  if (OctavusError.isInstance(error)) {
+    return error.retryable;
+  }
+  return false;
+}
+function isValidationError(error) {
+  return OctavusError.isInstance(error) && error.errorType === "validation_error";
+}
+
+// src/errors/helpers.ts
+function createErrorEvent(options) {
+  return {
+    type: "error",
+    errorType: options.errorType,
+    message: options.message,
+    source: options.source,
+    retryable: options.retryable ?? false,
+    retryAfter: options.retryAfter,
+    code: options.code,
+    provider: options.provider,
+    tool: options.tool
+  };
+}
+function errorToStreamEvent(error) {
+  return createErrorEvent({
+    errorType: error.errorType,
+    message: error.message,
+    source: error.source,
+    retryable: error.retryable,
+    retryAfter: error.retryAfter,
+    code: error.code,
+    provider: error.provider,
+    tool: error.tool
+  });
+}
+function createInternalErrorEvent(message) {
+  return createErrorEvent({
+    errorType: "internal_error",
+    message,
+    source: "platform",
+    retryable: false
+  });
+}
+function mapStatusCodeToErrorType(statusCode) {
+  switch (statusCode) {
+    case 400:
+      return "validation_error";
+    case 401:
+      return "authentication_error";
+    case 403:
+      return "permission_error";
+    case 404:
+      return "not_found_error";
+    case 429:
+      return "rate_limit_error";
+    case 503:
+      return "provider_overloaded";
+    case 504:
+      return "provider_timeout";
+    default:
+      return statusCode >= 500 ? "internal_error" : "unknown_error";
+  }
+}
+function createApiErrorEvent(statusCode, message) {
+  const errorType = mapStatusCodeToErrorType(statusCode);
+  const retryable = statusCode === 429 || statusCode >= 500;
+  return createErrorEvent({
+    errorType,
+    message,
+    source: "platform",
+    retryable
+  });
+}
+
+// src/utils.ts
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+function isAbortError(error) {
+  return (error instanceof Error || error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
+  error.name === "TimeoutError");
+}
+
+// src/thread.ts
+var MAIN_THREAD = "main";
+function resolveThread(thread) {
+  return thread ?? MAIN_THREAD;
+}
+function isMainThread(thread) {
+  return thread === void 0 || thread === MAIN_THREAD;
+}
+function threadForPart(thread) {
+  return isMainThread(thread) ? void 0 : thread;
+}
+function isOtherThread(part) {
+  return !isMainThread(part.thread);
+}
+
+// src/stream/schemas.ts
+var import_zod = require("zod");
+var displayModeSchema = import_zod.z.enum(["hidden", "name", "description", "stream"]);
+var messageRoleSchema = import_zod.z.enum(["user", "assistant", "system"]);
+var toolCallStatusSchema = import_zod.z.enum(["pending", "streaming", "available", "error"]);
+var finishReasonSchema = import_zod.z.enum([
+  "stop",
+  "tool-calls",
+  "client-tool-calls",
+  "length",
+  "content-filter",
+  "error",
+  "other"
+]);
+var toolCallInfoSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  arguments: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()),
+  status: toolCallStatusSchema,
+  result: import_zod.z.unknown().optional(),
+  error: import_zod.z.string().optional(),
+  thoughtSignature: import_zod.z.string().optional(),
+  display: displayModeSchema.optional()
+});
+var startEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("start"),
+  messageId: import_zod.z.string().optional(),
+  executionId: import_zod.z.string().optional(),
+  lastMessageId: import_zod.z.string().optional()
+});
+var finishEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("finish"),
+  finishReason: finishReasonSchema,
+  executionId: import_zod.z.string().optional()
+});
+var errorTypeSchema = import_zod.z.enum([
+  "authentication_error",
+  "permission_error",
+  "validation_error",
+  "not_found_error",
+  "rate_limit_error",
+  "quota_exceeded_error",
+  "provider_error",
+  "provider_overloaded",
+  "provider_timeout",
+  "execution_error",
+  "tool_error",
+  "protocol_error",
+  "internal_error",
+  "unknown_error"
+]);
+var errorSourceSchema = import_zod.z.enum(["platform", "provider", "tool", "client"]);
+var providerErrorInfoSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  model: import_zod.z.string().optional(),
+  statusCode: import_zod.z.number().optional(),
+  errorType: import_zod.z.string().optional(),
+  requestId: import_zod.z.string().optional()
+});
+var toolErrorInfoSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  callId: import_zod.z.string().optional()
+});
+var errorEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("error"),
+  errorType: errorTypeSchema,
+  message: import_zod.z.string(),
+  retryable: import_zod.z.boolean(),
+  source: errorSourceSchema,
+  retryAfter: import_zod.z.number().optional(),
+  code: import_zod.z.string().optional(),
+  provider: providerErrorInfoSchema.optional(),
+  tool: toolErrorInfoSchema.optional()
+});
+var textStartEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("text-start"),
+  id: import_zod.z.string(),
+  responseType: import_zod.z.string().optional(),
+  workerId: import_zod.z.string().optional()
+});
+var textDeltaEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("text-delta"),
+  id: import_zod.z.string(),
+  delta: import_zod.z.string(),
+  workerId: import_zod.z.string().optional()
+});
+var textEndEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("text-end"),
+  id: import_zod.z.string(),
+  workerId: import_zod.z.string().optional()
+});
+var reasoningStartEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("reasoning-start"),
+  id: import_zod.z.string(),
+  workerId: import_zod.z.string().optional()
+});
+var reasoningDeltaEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("reasoning-delta"),
+  id: import_zod.z.string(),
+  delta: import_zod.z.string(),
+  workerId: import_zod.z.string().optional()
+});
+var reasoningEndEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("reasoning-end"),
+  id: import_zod.z.string(),
+  workerId: import_zod.z.string().optional()
+});
+var toolInputStartEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool-input-start"),
+  toolCallId: import_zod.z.string(),
+  toolName: import_zod.z.string(),
+  title: import_zod.z.string().optional(),
+  workerId: import_zod.z.string().optional()
+});
+var toolInputDeltaEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool-input-delta"),
+  toolCallId: import_zod.z.string(),
+  inputTextDelta: import_zod.z.string(),
+  workerId: import_zod.z.string().optional()
+});
+var toolInputEndEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool-input-end"),
+  toolCallId: import_zod.z.string(),
+  workerId: import_zod.z.string().optional()
+});
+var toolInputAvailableEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool-input-available"),
+  toolCallId: import_zod.z.string(),
+  toolName: import_zod.z.string(),
+  input: import_zod.z.unknown(),
+  workerId: import_zod.z.string().optional()
+});
+var toolOutputAvailableEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool-output-available"),
+  toolCallId: import_zod.z.string(),
+  output: import_zod.z.unknown(),
+  workerId: import_zod.z.string().optional()
+});
+var toolOutputErrorEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool-output-error"),
+  toolCallId: import_zod.z.string(),
+  error: import_zod.z.string(),
+  workerId: import_zod.z.string().optional()
+});
+var sourceUrlEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("source"),
+  sourceType: import_zod.z.literal("url"),
+  id: import_zod.z.string(),
+  url: import_zod.z.string(),
+  title: import_zod.z.string().optional(),
+  workerId: import_zod.z.string().optional()
+});
+var sourceDocumentEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("source"),
+  sourceType: import_zod.z.literal("document"),
+  id: import_zod.z.string(),
+  mediaType: import_zod.z.string(),
+  title: import_zod.z.string(),
+  filename: import_zod.z.string().optional(),
+  workerId: import_zod.z.string().optional()
+});
+var sourceEventSchema = import_zod.z.discriminatedUnion("sourceType", [
+  sourceUrlEventSchema,
+  sourceDocumentEventSchema
+]);
+var blockStartEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("block-start"),
+  blockId: import_zod.z.string(),
+  blockName: import_zod.z.string(),
+  blockType: import_zod.z.string(),
+  display: displayModeSchema,
+  description: import_zod.z.string().optional(),
+  outputToChat: import_zod.z.boolean().optional(),
+  thread: import_zod.z.string().optional(),
+  workerId: import_zod.z.string().optional()
+});
+var blockEndEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("block-end"),
+  blockId: import_zod.z.string(),
+  summary: import_zod.z.string().optional(),
+  workerId: import_zod.z.string().optional()
+});
+var resourceUpdateEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("resource-update"),
+  name: import_zod.z.string(),
+  value: import_zod.z.unknown()
+});
+var fileReferenceSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  mediaType: import_zod.z.string(),
+  url: import_zod.z.string(),
+  filename: import_zod.z.string().optional(),
+  size: import_zod.z.number().optional()
+});
+var pendingToolCallSchema = import_zod.z.object({
+  toolCallId: import_zod.z.string(),
+  toolName: import_zod.z.string(),
+  args: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()),
+  source: import_zod.z.enum(["llm", "block"]).optional(),
+  outputVariable: import_zod.z.string().optional(),
+  blockIndex: import_zod.z.number().optional(),
+  thread: import_zod.z.string().optional(),
+  workerId: import_zod.z.string().optional()
+});
+var toolResultSchema = import_zod.z.object({
+  toolCallId: import_zod.z.string(),
+  toolName: import_zod.z.string().optional(),
+  result: import_zod.z.unknown().optional(),
+  error: import_zod.z.string().optional(),
+  files: import_zod.z.array(fileReferenceSchema).optional(),
+  outputVariable: import_zod.z.string().optional(),
+  blockIndex: import_zod.z.number().optional(),
+  thread: import_zod.z.string().optional(),
+  workerId: import_zod.z.string().optional()
+});
+var toolRequestEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool-request"),
+  toolCalls: import_zod.z.array(pendingToolCallSchema),
+  workerId: import_zod.z.string().optional()
+});
+var clientToolRequestEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("client-tool-request"),
+  executionId: import_zod.z.string(),
+  toolCalls: import_zod.z.array(pendingToolCallSchema),
+  serverToolResults: import_zod.z.array(toolResultSchema).optional()
+});
+var fileAvailableEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("file-available"),
+  id: import_zod.z.string(),
+  mediaType: import_zod.z.string(),
+  url: import_zod.z.string(),
+  filename: import_zod.z.string().optional(),
+  size: import_zod.z.number().optional(),
+  toolCallId: import_zod.z.string().optional(),
+  workerId: import_zod.z.string().optional()
+});
+var workerStartEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("worker-start"),
+  workerId: import_zod.z.string(),
+  workerSlug: import_zod.z.string(),
+  description: import_zod.z.string().optional()
+});
+var workerResultEventSchema = import_zod.z.object({
+  type: import_zod.z.literal("worker-result"),
+  workerId: import_zod.z.string(),
+  output: import_zod.z.unknown().optional(),
+  error: import_zod.z.string().optional()
+});
+var streamEventSchema = import_zod.z.union([
+  // Lifecycle events
+  startEventSchema,
+  finishEventSchema,
+  errorEventSchema,
+  // Text events
+  textStartEventSchema,
+  textDeltaEventSchema,
+  textEndEventSchema,
+  // Reasoning events
+  reasoningStartEventSchema,
+  reasoningDeltaEventSchema,
+  reasoningEndEventSchema,
+  // Tool events
+  toolInputStartEventSchema,
+  toolInputDeltaEventSchema,
+  toolInputEndEventSchema,
+  toolInputAvailableEventSchema,
+  toolOutputAvailableEventSchema,
+  toolOutputErrorEventSchema,
+  // Source events
+  sourceEventSchema,
+  // Octavus-specific events
+  blockStartEventSchema,
+  blockEndEventSchema,
+  resourceUpdateEventSchema,
+  toolRequestEventSchema,
+  clientToolRequestEventSchema,
+  fileAvailableEventSchema,
+  // Worker events
+  workerStartEventSchema,
+  workerResultEventSchema
+]);
+var messagePartTypeSchema = import_zod.z.enum([
+  "text",
+  "reasoning",
+  "tool-call",
+  "operation",
+  "source",
+  "file",
+  "object",
+  "worker"
+]);
+var sourceUrlInfoSchema = import_zod.z.object({
+  sourceType: import_zod.z.literal("url"),
+  id: import_zod.z.string(),
+  url: import_zod.z.string(),
+  title: import_zod.z.string().optional()
+});
+var sourceDocumentInfoSchema = import_zod.z.object({
+  sourceType: import_zod.z.literal("document"),
+  id: import_zod.z.string(),
+  mediaType: import_zod.z.string(),
+  title: import_zod.z.string(),
+  filename: import_zod.z.string().optional()
+});
+var sourceInfoSchema = import_zod.z.discriminatedUnion("sourceType", [
+  sourceUrlInfoSchema,
+  sourceDocumentInfoSchema
+]);
+var fileInfoSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  mediaType: import_zod.z.string(),
+  url: import_zod.z.string(),
+  filename: import_zod.z.string().optional(),
+  size: import_zod.z.number().optional(),
+  toolCallId: import_zod.z.string().optional()
+});
+var objectInfoSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  typeName: import_zod.z.string(),
+  value: import_zod.z.unknown()
+});
+var operationInfoSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  operationType: import_zod.z.string()
+});
+var baseMessagePartSchema = import_zod.z.object({
+  type: import_zod.z.enum(["text", "reasoning", "tool-call", "operation", "source", "file", "object"]),
+  visible: import_zod.z.boolean(),
+  content: import_zod.z.string().optional(),
+  toolCall: toolCallInfoSchema.optional(),
+  operation: operationInfoSchema.optional(),
+  source: sourceInfoSchema.optional(),
+  file: fileInfoSchema.optional(),
+  object: objectInfoSchema.optional(),
+  thread: import_zod.z.string().optional()
+});
+var workerPartInfoSchema = import_zod.z.object({
+  workerId: import_zod.z.string(),
+  workerSlug: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  // Worker nested parts can contain base parts (text, reasoning, tools, etc.) but not nested workers
+  nestedParts: import_zod.z.array(baseMessagePartSchema),
+  output: import_zod.z.unknown().optional(),
+  error: import_zod.z.string().optional()
+});
+var messagePartSchema = import_zod.z.object({
+  type: messagePartTypeSchema,
+  visible: import_zod.z.boolean(),
+  content: import_zod.z.string().optional(),
+  toolCall: toolCallInfoSchema.optional(),
+  operation: operationInfoSchema.optional(),
+  source: sourceInfoSchema.optional(),
+  file: fileInfoSchema.optional(),
+  object: objectInfoSchema.optional(),
+  worker: workerPartInfoSchema.optional(),
+  thread: import_zod.z.string().optional()
+});
+var chatMessageSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  role: messageRoleSchema,
+  parts: import_zod.z.array(messagePartSchema),
+  createdAt: import_zod.z.string(),
+  visible: import_zod.z.boolean().optional(),
+  content: import_zod.z.string(),
+  toolCalls: import_zod.z.array(toolCallInfoSchema).optional(),
+  reasoning: import_zod.z.string().optional(),
+  reasoningSignature: import_zod.z.string().optional()
+});
+var uiMessageStatusSchema = import_zod.z.enum(["streaming", "done"]);
+var uiPartStatusSchema = import_zod.z.enum(["streaming", "done"]);
+var uiToolCallStatusSchema = import_zod.z.enum(["pending", "running", "done", "error"]);
+var uiTextPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("text"),
+  text: import_zod.z.string(),
+  status: uiPartStatusSchema,
+  thread: import_zod.z.string().optional()
+});
+var uiReasoningPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("reasoning"),
+  text: import_zod.z.string(),
+  status: uiPartStatusSchema,
+  thread: import_zod.z.string().optional(),
+  providerMetadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+var uiToolCallPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("tool-call"),
+  toolCallId: import_zod.z.string(),
+  toolName: import_zod.z.string(),
+  displayName: import_zod.z.string().optional(),
+  args: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()),
+  result: import_zod.z.unknown().optional(),
+  error: import_zod.z.string().optional(),
+  status: uiToolCallStatusSchema,
+  thread: import_zod.z.string().optional(),
+  providerMetadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
+});
+var uiOperationStatusSchema = import_zod.z.enum(["running", "done"]);
+var uiOperationPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("operation"),
+  operationId: import_zod.z.string(),
+  name: import_zod.z.string(),
+  operationType: import_zod.z.string(),
+  status: uiOperationStatusSchema,
+  thread: import_zod.z.string().optional()
+});
+var uiSourceUrlPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("source"),
+  sourceType: import_zod.z.literal("url"),
+  id: import_zod.z.string(),
+  url: import_zod.z.string(),
+  title: import_zod.z.string().optional(),
+  thread: import_zod.z.string().optional()
+});
+var uiSourceDocumentPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("source"),
+  sourceType: import_zod.z.literal("document"),
+  id: import_zod.z.string(),
+  mediaType: import_zod.z.string(),
+  title: import_zod.z.string(),
+  filename: import_zod.z.string().optional(),
+  thread: import_zod.z.string().optional()
+});
+var uiSourcePartSchema = import_zod.z.discriminatedUnion("sourceType", [
+  uiSourceUrlPartSchema,
+  uiSourceDocumentPartSchema
+]);
+var uiFilePartSchema = import_zod.z.object({
+  type: import_zod.z.literal("file"),
+  id: import_zod.z.string(),
+  mediaType: import_zod.z.string(),
+  url: import_zod.z.string(),
+  filename: import_zod.z.string().optional(),
+  size: import_zod.z.number().optional(),
+  toolCallId: import_zod.z.string().optional(),
+  thread: import_zod.z.string().optional()
+});
+var uiObjectStatusSchema = import_zod.z.enum(["streaming", "done", "error"]);
+var uiObjectPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("object"),
+  id: import_zod.z.string(),
+  typeName: import_zod.z.string(),
+  partial: import_zod.z.unknown().optional(),
+  object: import_zod.z.unknown().optional(),
+  status: uiObjectStatusSchema,
+  error: import_zod.z.string().optional(),
+  thread: import_zod.z.string().optional()
+});
+var uiWorkerStatusSchema = import_zod.z.enum(["running", "done", "error"]);
+var baseUiMessagePartSchema = import_zod.z.union([
+  uiTextPartSchema,
+  uiReasoningPartSchema,
+  uiToolCallPartSchema,
+  uiOperationPartSchema,
+  uiSourcePartSchema,
+  uiFilePartSchema,
+  uiObjectPartSchema
+]);
+var uiWorkerPartSchema = import_zod.z.object({
+  type: import_zod.z.literal("worker"),
+  workerId: import_zod.z.string(),
+  workerSlug: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  // Worker parts can contain base parts (text, reasoning, tools, etc.) but not nested workers
+  parts: import_zod.z.array(baseUiMessagePartSchema),
+  output: import_zod.z.unknown().optional(),
+  error: import_zod.z.string().optional(),
+  status: uiWorkerStatusSchema
+});
+var uiMessagePartSchema = import_zod.z.union([
+  uiTextPartSchema,
+  uiReasoningPartSchema,
+  uiToolCallPartSchema,
+  uiOperationPartSchema,
+  uiSourcePartSchema,
+  uiFilePartSchema,
+  uiObjectPartSchema,
+  uiWorkerPartSchema
+]);
+var uiMessageSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  role: import_zod.z.enum(["user", "assistant"]),
+  parts: import_zod.z.array(uiMessagePartSchema),
+  status: uiMessageStatusSchema,
+  createdAt: import_zod.z.coerce.date()
+});
+function safeParseStreamEvent(data) {
+  return streamEventSchema.safeParse(data);
+}
+function safeParseUIMessage(data) {
+  return uiMessageSchema.safeParse(data);
+}
+function safeParseUIMessages(data) {
+  return import_zod.z.array(uiMessageSchema).safeParse(data);
+}
+function isFileReference(value) {
+  return fileReferenceSchema.safeParse(value).success;
+}
+function isFileReferenceArray(value) {
+  return import_zod.z.array(fileReferenceSchema).safeParse(value).success;
+}
+
+// src/internal-tools.ts
+var OCTAVUS_INTERNAL_PREFIX = "octavus_";
+var OCTAVUS_INTERNAL_TOOLS = {
+  // === Skill Tools (executed in E2B sandboxes) ===
+  /** Read skill documentation (SKILL.md) */
+  SKILL_READ: "octavus_skill_read",
+  /** List available scripts in a skill */
+  SKILL_LIST: "octavus_skill_list",
+  /** Execute a pre-built skill script */
+  SKILL_RUN: "octavus_skill_run",
+  /** Execute Python/Bash code in sandbox */
+  CODE_RUN: "octavus_code_run",
+  /** Create/write files in sandbox */
+  FILE_WRITE: "octavus_file_write",
+  /** Read files from sandbox */
+  FILE_READ: "octavus_file_read",
+  // === Reference Tools (agent-local documents fetched on demand) ===
+  /** List all available references with descriptions */
+  REFERENCE_LIST: "octavus_reference_list",
+  /** Read the full content of a specific reference */
+  REFERENCE_READ: "octavus_reference_read",
+  // === Image Generation ===
+  /** Generate images using AI models */
+  GENERATE_IMAGE: "octavus_generate_image",
+  // === Web Search ===
+  /** Search the web for current information */
+  WEB_SEARCH: "octavus_web_search"
+};
+function isOctavusInternalTool(toolName) {
+  return toolName.startsWith(OCTAVUS_INTERNAL_PREFIX);
+}
+var OCTAVUS_SKILL_TOOLS = {
+  SKILL_READ: OCTAVUS_INTERNAL_TOOLS.SKILL_READ,
+  SKILL_LIST: OCTAVUS_INTERNAL_TOOLS.SKILL_LIST,
+  SKILL_RUN: OCTAVUS_INTERNAL_TOOLS.SKILL_RUN,
+  CODE_RUN: OCTAVUS_INTERNAL_TOOLS.CODE_RUN,
+  FILE_WRITE: OCTAVUS_INTERNAL_TOOLS.FILE_WRITE,
+  FILE_READ: OCTAVUS_INTERNAL_TOOLS.FILE_READ
+};
+function isOctavusSkillTool(toolName) {
+  return Object.values(OCTAVUS_SKILL_TOOLS).includes(toolName);
+}
+var OCTAVUS_REFERENCE_TOOLS = {
+  REFERENCE_LIST: OCTAVUS_INTERNAL_TOOLS.REFERENCE_LIST,
+  REFERENCE_READ: OCTAVUS_INTERNAL_TOOLS.REFERENCE_READ
+};
+function isOctavusReferenceTool(toolName) {
+  return Object.values(OCTAVUS_REFERENCE_TOOLS).includes(toolName);
+}
+
+// src/skills.ts
+function getSkillSlugFromToolCall(toolName, args) {
+  if (!isOctavusSkillTool(toolName) || !args) {
+    return void 0;
+  }
+  if (typeof args.skill === "string") {
+    return args.skill;
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppError,
+  ConflictError,
+  ForbiddenError,
+  MAIN_THREAD,
+  NotFoundError,
+  OCTAVUS_INTERNAL_PREFIX,
+  OCTAVUS_INTERNAL_TOOLS,
+  OCTAVUS_REFERENCE_TOOLS,
+  OCTAVUS_SKILL_TOOLS,
+  OctavusError,
+  ValidationError,
+  chatMessageSchema,
+  createApiErrorEvent,
+  createErrorEvent,
+  createInternalErrorEvent,
+  errorToStreamEvent,
+  fileReferenceSchema,
+  generateId,
+  getSkillSlugFromToolCall,
+  isAbortError,
+  isAuthenticationError,
+  isFileReference,
+  isFileReferenceArray,
+  isMainThread,
+  isOctavusInternalTool,
+  isOctavusReferenceTool,
+  isOctavusSkillTool,
+  isOtherThread,
+  isProviderError,
+  isRateLimitError,
+  isRetryableError,
+  isToolError,
+  isValidationError,
+  resolveThread,
+  safeParseStreamEvent,
+  safeParseUIMessage,
+  safeParseUIMessages,
+  threadForPart,
+  toolResultSchema,
+  uiMessagePartSchema,
+  uiMessageSchema,
+  uiWorkerPartSchema,
+  uiWorkerStatusSchema
+});
+//# sourceMappingURL=index.cjs.map