@perstack/core 0.0.1

package/dist/index.js

@@ -0,0 +1,697 @@
+import { z } from 'zod';
+import { createId } from '@paralleldrive/cuid2';
+
+// src/constants/constants.ts
+var defaultPerstackApiBaseUrl = "https://api.perstack.ai";
+var organizationNameRegex = /^[a-z0-9][a-z0-9_\.-]*$/;
+var maxOrganizationNameLength = 128;
+var maxApplicationNameLength = 255;
+var expertKeyRegex = /^((?:@[a-z0-9][a-z0-9_\.-]*\/)?[a-z0-9][a-z0-9_\.-]*)(?:@((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?)|@([a-z0-9][a-z0-9_\.-]*))?$/;
+var expertNameRegex = /^(@[a-z0-9][a-z0-9_-]*\/)?[a-z0-9][a-z0-9_-]*$/;
+var expertVersionRegex = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?$/;
+var tagNameRegex = /^[a-z0-9][a-z0-9_-]*$/;
+var maxExpertNameLength = 255;
+var maxExpertVersionTagLength = 255;
+var maxExpertKeyLength = 511;
+var maxExpertDescriptionLength = 1024 * 2;
+var maxExpertInstructionLength = 1024 * 20;
+var maxExpertSkillItems = 255;
+var maxExpertDelegateItems = 255;
+var maxExpertTagItems = 8;
+var defaultTemperature = 0;
+var defaultMaxSteps = void 0;
+var defaultMaxRetries = 5;
+var defaultTimeout = 5 * 1e3 * 60;
+var maxExpertJobQueryLength = 1024 * 20;
+var maxExpertJobFileNameLength = 1024 * 10;
+var packageWithVersionRegex = /^(?:@[a-z0-9][a-z0-9_\.-]*\/)?[a-z0-9][a-z0-9_\.-]*(?:@(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?|@[a-z0-9][a-z0-9_\.-]*)?$/;
+var urlSafeRegex = /^[a-z0-9][a-z0-9_-]*$/;
+var maxSkillNameLength = 255;
+var maxSkillDescriptionLength = 1024 * 2;
+var maxSkillRuleLength = 1024 * 2;
+var maxSkillPickOmitItems = 255;
+var maxSkillRequiredEnvItems = 255;
+var maxSkillToolNameLength = 255;
+var maxSkillEndpointLength = 1024 * 2;
+var maxSkillInputJsonSchemaLength = 1024 * 20;
+var maxSkillToolItems = 255;
+var maxCheckpointToolCallIdLength = 255;
+var envNameRegex = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+var maxEnvNameLength = 255;
+var basePartSchema = z.object({
+  id: z.string()
+});
+var textPartSchema = basePartSchema.extend({
+  type: z.literal("textPart"),
+  text: z.string()
+});
+var imageUrlPartSchema = basePartSchema.extend({
+  type: z.literal("imageUrlPart"),
+  url: z.url(),
+  mimeType: z.string()
+});
+var imageInlinePartSchema = basePartSchema.extend({
+  type: z.literal("imageInlinePart"),
+  encodedData: z.string(),
+  mimeType: z.string()
+});
+var imageBinaryPartSchema = basePartSchema.extend({
+  type: z.literal("imageBinaryPart"),
+  data: z.string(),
+  mimeType: z.string()
+});
+var fileUrlPartSchema = basePartSchema.extend({
+  type: z.literal("fileUrlPart"),
+  url: z.string().url(),
+  mimeType: z.string()
+});
+var fileInlinePartSchema = basePartSchema.extend({
+  type: z.literal("fileInlinePart"),
+  encodedData: z.string(),
+  mimeType: z.string()
+});
+var fileBinaryPartSchema = basePartSchema.extend({
+  type: z.literal("fileBinaryPart"),
+  data: z.string(),
+  mimeType: z.string()
+});
+var toolCallPartSchema = basePartSchema.extend({
+  type: z.literal("toolCallPart"),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  args: z.unknown()
+});
+var toolResultPartSchema = basePartSchema.extend({
+  type: z.literal("toolResultPart"),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  contents: z.array(z.union([textPartSchema, imageInlinePartSchema])),
+  isError: z.boolean().optional()
+});
+var messagePartSchema = z.discriminatedUnion("type", [
+  textPartSchema,
+  imageUrlPartSchema,
+  imageInlinePartSchema,
+  imageBinaryPartSchema,
+  fileUrlPartSchema,
+  fileInlinePartSchema,
+  fileBinaryPartSchema,
+  toolCallPartSchema,
+  toolResultPartSchema
+]);
+
+// src/schemas/message.ts
+var baseMessageSchema = z.object({
+  id: z.string()
+});
+var instructionMessageSchema = baseMessageSchema.extend({
+  type: z.literal("instructionMessage"),
+  contents: z.array(textPartSchema),
+  cache: z.boolean().optional()
+});
+var userMessageSchema = baseMessageSchema.extend({
+  type: z.literal("userMessage"),
+  contents: z.array(
+    z.union([
+      textPartSchema,
+      imageUrlPartSchema,
+      imageInlinePartSchema,
+      imageBinaryPartSchema,
+      fileUrlPartSchema,
+      fileInlinePartSchema,
+      fileBinaryPartSchema
+    ])
+  ),
+  cache: z.boolean().optional()
+});
+var expertMessageSchema = baseMessageSchema.extend({
+  type: z.literal("expertMessage"),
+  contents: z.array(z.union([textPartSchema, toolCallPartSchema])),
+  cache: z.boolean().optional()
+});
+var toolMessageSchema = baseMessageSchema.extend({
+  type: z.literal("toolMessage"),
+  contents: z.array(toolResultPartSchema),
+  cache: z.boolean().optional()
+});
+var messageSchema = z.union([
+  instructionMessageSchema,
+  userMessageSchema,
+  expertMessageSchema,
+  toolMessageSchema
+]);
+var usageSchema = z.object({
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  reasoningTokens: z.number(),
+  totalTokens: z.number(),
+  cachedInputTokens: z.number()
+});
+
+// src/schemas/checkpoint.ts
+var checkpointStatusSchema = z.enum([
+  "init",
+  "proceeding",
+  "completed",
+  "stoppedByInteractiveTool",
+  "stoppedByDelegate",
+  "stoppedByExceededMaxSteps",
+  "stoppedByError"
+]);
+var checkpointSchema = z.object({
+  id: z.string(),
+  runId: z.string(),
+  status: checkpointStatusSchema,
+  stepNumber: z.number(),
+  messages: z.array(messageSchema),
+  expert: z.object({
+    key: z.string(),
+    name: z.string(),
+    version: z.string()
+  }),
+  delegateTo: z.object({
+    expert: z.object({
+      key: z.string(),
+      name: z.string(),
+      version: z.string()
+    }),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    query: z.string()
+  }).optional(),
+  delegatedBy: z.object({
+    expert: z.object({
+      key: z.string(),
+      name: z.string(),
+      version: z.string()
+    }),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    checkpointId: z.string()
+  }).optional(),
+  usage: usageSchema,
+  contextWindow: z.number().optional(),
+  contextWindowUsage: z.number().optional()
+});
+var mcpStdioSkillSchema = z.object({
+  type: z.literal("mcpStdioSkill"),
+  name: z.string(),
+  description: z.string().optional(),
+  rule: z.string().optional(),
+  pick: z.array(z.string()).optional().default([]),
+  omit: z.array(z.string()).optional().default([]),
+  command: z.string(),
+  packageName: z.string().optional(),
+  args: z.array(z.string()).optional().default([]),
+  requiredEnv: z.array(z.string()).optional().default([])
+});
+var mcpSseSkillSchema = z.object({
+  type: z.literal("mcpSseSkill"),
+  name: z.string(),
+  description: z.string().optional(),
+  rule: z.string().optional(),
+  pick: z.array(z.string()).optional().default([]),
+  omit: z.array(z.string()).optional().default([]),
+  endpoint: z.string()
+});
+var interactiveToolSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  inputJsonSchema: z.string()
+});
+var interactiveSkillSchema = z.object({
+  type: z.literal("interactiveSkill"),
+  name: z.string(),
+  description: z.string().optional(),
+  rule: z.string().optional(),
+  tools: z.record(z.string(), interactiveToolSchema.omit({ name: true })).transform((tools) => {
+    return Object.fromEntries(
+      Object.entries(tools).map(([key, toolWithoutName]) => [
+        key,
+        interactiveToolSchema.parse({ ...toolWithoutName, name: key })
+      ])
+    );
+  })
+});
+var skillSchema = z.discriminatedUnion("type", [
+  mcpStdioSkillSchema,
+  mcpSseSkillSchema,
+  interactiveSkillSchema
+]);
+
+// src/schemas/expert.ts
+var expertSchema = z.object({
+  key: z.string().regex(expertKeyRegex).min(1),
+  name: z.string().regex(expertNameRegex).min(1).max(maxExpertNameLength),
+  version: z.string().regex(expertVersionRegex),
+  description: z.string().min(1).max(1024 * 2).optional(),
+  instruction: z.string().min(1).max(1024 * 20),
+  skills: z.record(
+    z.string(),
+    z.discriminatedUnion("type", [
+      mcpStdioSkillSchema.omit({ name: true }),
+      mcpSseSkillSchema.omit({ name: true }),
+      interactiveSkillSchema.omit({ name: true })
+    ])
+  ).optional().default({
+    "@perstack/base": {
+      type: "mcpStdioSkill",
+      description: "Base skill",
+      command: "npx",
+      args: ["-y", "@perstack/base"],
+      pick: [],
+      omit: [],
+      requiredEnv: []
+    }
+  }).transform((skills) => {
+    return Object.fromEntries(
+      Object.entries(skills).map(([key, skillWithoutName]) => [
+        key,
+        z.discriminatedUnion("type", [
+          mcpStdioSkillSchema,
+          mcpSseSkillSchema,
+          interactiveSkillSchema
+        ]).parse({ ...skillWithoutName, name: key })
+      ])
+    );
+  }),
+  delegates: z.array(z.string().regex(expertKeyRegex).min(1)).optional().default([]),
+  tags: z.array(z.string().regex(tagNameRegex).min(1)).optional().default([])
+});
+var providerNameSchema = z.enum([
+  "anthropic",
+  "google",
+  "openai",
+  "ollama",
+  "azure-openai",
+  "amazon-bedrock"
+]);
+var anthropicProviderConfigSchema = z.object({
+  name: z.literal(providerNameSchema.enum.anthropic),
+  apiKey: z.string(),
+  baseUrl: z.string().optional()
+});
+var googleGenerativeAiProviderConfigSchema = z.object({
+  name: z.literal(providerNameSchema.enum.google),
+  apiKey: z.string(),
+  baseUrl: z.string().optional()
+});
+var openAiProviderConfigSchema = z.object({
+  name: z.literal(providerNameSchema.enum.openai),
+  apiKey: z.string(),
+  baseUrl: z.string().optional(),
+  organization: z.string().optional(),
+  project: z.string().optional()
+});
+var ollamaProviderConfigSchema = z.object({
+  name: z.literal(providerNameSchema.enum.ollama),
+  baseUrl: z.string().optional()
+});
+var azureOpenAiProviderConfigSchema = z.object({
+  name: z.literal(providerNameSchema.enum["azure-openai"]),
+  apiKey: z.string(),
+  resourceName: z.string(),
+  apiVersion: z.string().optional()
+});
+var amazonBedrockProviderConfigSchema = z.object({
+  name: z.literal(providerNameSchema.enum["amazon-bedrock"]),
+  accessKeyId: z.string(),
+  secretAccessKey: z.string(),
+  region: z.string(),
+  sessionToken: z.string().optional()
+});
+var providerConfigSchema = z.discriminatedUnion("name", [
+  anthropicProviderConfigSchema,
+  googleGenerativeAiProviderConfigSchema,
+  openAiProviderConfigSchema,
+  ollamaProviderConfigSchema,
+  azureOpenAiProviderConfigSchema,
+  amazonBedrockProviderConfigSchema
+]);
+
+// src/schemas/perstack-toml.ts
+var perstackConfigSchema = z.object({
+  provider: providerNameSchema.optional(),
+  model: z.string().optional(),
+  temperature: z.number().optional(),
+  maxSteps: z.number().optional(),
+  maxRetries: z.number().optional(),
+  timeout: z.number().optional(),
+  experts: z.record(
+    z.string(),
+    z.object({
+      version: z.string().optional(),
+      minRuntimeVersion: z.string().optional(),
+      description: z.string().optional(),
+      instruction: z.string(),
+      skills: z.record(
+        z.string(),
+        z.discriminatedUnion("type", [
+          z.object({
+            type: z.literal("mcpStdioSkill"),
+            description: z.string().optional(),
+            rule: z.string().optional(),
+            pick: z.array(z.string()).optional(),
+            omit: z.array(z.string()).optional(),
+            command: z.string(),
+            packageName: z.string().optional(),
+            args: z.array(z.string()).optional(),
+            requiredEnv: z.array(z.string()).optional()
+          }),
+          z.object({
+            type: z.literal("mcpSseSkill"),
+            description: z.string().optional(),
+            rule: z.string().optional(),
+            pick: z.array(z.string()).optional(),
+            omit: z.array(z.string()).optional(),
+            endpoint: z.string()
+          }),
+          z.object({
+            type: z.literal("interactiveSkill"),
+            description: z.string().optional(),
+            rule: z.string().optional(),
+            tools: z.record(
+              z.string(),
+              z.object({
+                description: z.string().optional(),
+                inputJsonSchema: z.string()
+              })
+            )
+          })
+        ])
+      ).optional(),
+      delegates: z.array(z.string()).optional()
+    })
+  ).optional(),
+  perstackApiBaseUrl: z.url().optional(),
+  perstackBaseSkillArgs: z.array(z.string()).optional(),
+  envPath: z.array(z.string()).optional()
+});
+var runCommandInputSchema = z.object({
+  expertKey: z.string(),
+  query: z.string(),
+  options: z.object({
+    config: z.string().optional(),
+    provider: providerNameSchema.optional(),
+    model: z.string().optional(),
+    temperature: z.string().optional().transform((value) => {
+      if (value === void 0) {
+        return void 0;
+      }
+      const parsedValue = Number.parseFloat(value);
+      if (Number.isNaN(parsedValue)) {
+        return void 0;
+      }
+      return parsedValue;
+    }),
+    maxSteps: z.string().optional().transform((value) => {
+      if (value === void 0) {
+        return void 0;
+      }
+      const parsedValue = Number.parseInt(value);
+      if (Number.isNaN(parsedValue)) {
+        return void 0;
+      }
+      return parsedValue;
+    }),
+    maxRetries: z.string().optional().transform((value) => {
+      if (value === void 0) {
+        return void 0;
+      }
+      const parsedValue = Number.parseInt(value);
+      if (Number.isNaN(parsedValue)) {
+        return void 0;
+      }
+      return parsedValue;
+    }),
+    timeout: z.string().optional().transform((value) => {
+      if (value === void 0) {
+        return void 0;
+      }
+      const parsedValue = Number.parseInt(value);
+      if (Number.isNaN(parsedValue)) {
+        return void 0;
+      }
+      return parsedValue;
+    }),
+    runId: z.string().optional(),
+    envPath: z.array(z.string()).optional()
+  })
+});
+function parseExpertKey(expertKey) {
+  const match = expertKey.match(expertKeyRegex);
+  if (!match) {
+    throw new Error(`Invalid expert key format: ${expertKey}`);
+  }
+  const [key, name, version, tag] = match;
+  return {
+    key,
+    name,
+    version,
+    tag
+  };
+}
+var runParamsSchema = z.object({
+  setting: z.object({
+    model: z.string(),
+    providerConfig: providerConfigSchema,
+    runId: z.string().optional().default(createId()),
+    expertKey: z.string().min(1).regex(expertKeyRegex),
+    input: z.object({
+      text: z.string().optional(),
+      interactiveToolCallResult: z.object({
+        toolCallId: z.string(),
+        toolName: z.string(),
+        text: z.string()
+      }).optional()
+    }),
+    experts: z.record(z.string().min(1).regex(expertKeyRegex), expertSchema.omit({ key: true })).optional().default({}).transform(
+      (experts) => Object.fromEntries(
+        Object.entries(experts).map(([key, expertWithoutKey]) => [
+          key,
+          expertSchema.parse({
+            ...expertWithoutKey,
+            key
+          })
+        ])
+      )
+    ),
+    temperature: z.number().min(0).max(1).optional().default(defaultTemperature),
+    maxSteps: z.number().min(1).optional(),
+    maxRetries: z.number().min(0).optional().default(defaultMaxRetries),
+    timeout: z.number().min(0).optional().default(defaultTimeout),
+    workspace: z.string().optional(),
+    startedAt: z.number().optional().default(Date.now()),
+    updatedAt: z.number().optional().default(Date.now()),
+    perstackApiBaseUrl: z.url().optional().default(defaultPerstackApiBaseUrl),
+    perstackApiKey: z.string().optional(),
+    perstackBaseSkillArgs: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional().default({})
+  }),
+  checkpoint: checkpointSchema.optional()
+});
+function createEvent(type) {
+  return (setting, checkpoint, data) => {
+    return {
+      type,
+      id: createId(),
+      expertKey: checkpoint.expert.key,
+      timestamp: Date.now(),
+      runId: setting.runId,
+      stepNumber: checkpoint.stepNumber,
+      ...data
+    };
+  };
+}
+var startRun = createEvent("startRun");
+var startGeneration = createEvent("startGeneration");
+var retry = createEvent("retry");
+var callTool = createEvent("callTool");
+var callInteractiveTool = createEvent("callInteractiveTool");
+var callDelegate = createEvent("callDelegate");
+var resolveToolResult = createEvent("resolveToolResult");
+var resolveThought = createEvent("resolveThought");
+var resolvePdfFile = createEvent("resolvePdfFile");
+var resolveImageFile = createEvent("resolveImageFile");
+var attemptCompletion = createEvent("attemptCompletion");
+var finishToolCall = createEvent("finishToolCall");
+var completeRun = createEvent("completeRun");
+var stopRunByInteractiveTool = createEvent("stopRunByInteractiveTool");
+var stopRunByDelegate = createEvent("stopRunByDelegate");
+var stopRunByExceededMaxSteps = createEvent("stopRunByExceededMaxSteps");
+var continueToNextStep = createEvent("continueToNextStep");
+var toolCallSchema = z.object({
+  id: z.string().min(1).max(255),
+  skillName: z.string().min(1).max(maxSkillNameLength),
+  toolName: z.string().min(1).max(maxSkillToolNameLength),
+  args: z.record(z.string().min(1), z.unknown())
+});
+var toolResultSchema = z.object({
+  id: z.string().min(1).max(255),
+  skillName: z.string().min(1).max(maxSkillNameLength),
+  toolName: z.string().min(1).max(maxSkillToolNameLength),
+  result: z.array(messagePartSchema)
+});
+
+// src/schemas/step.ts
+var stepSchema = z.object({
+  stepNumber: z.number(),
+  inputMessages: z.array(z.union([instructionMessageSchema, userMessageSchema, toolMessageSchema])).optional(),
+  newMessages: z.array(messageSchema),
+  toolCall: toolCallSchema.optional(),
+  toolResult: toolResultSchema.optional(),
+  usage: usageSchema,
+  startedAt: z.number(),
+  finishedAt: z.number().optional()
+});
+
+// src/known-models/index.ts
+var knownModels = [
+  {
+    provider: "anthropic",
+    models: [
+      // https://docs.claude.com/en/docs/about-claude/models/overview#model-comparison-table
+      {
+        name: "claude-opus-4-20250514",
+        contextWindow: 2e5,
+        maxOutputTokens: 32e3
+      },
+      {
+        name: "claude-sonnet-4-20250514",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3
+      },
+      {
+        name: "claude-3-7-sonnet-20250219",
+        contextWindow: 2e5,
+        maxOutputTokens: 64e3
+      },
+      {
+        name: "claude-3-5-haiku-latest",
+        contextWindow: 2e5,
+        maxOutputTokens: 8192
+      }
+    ]
+  },
+  {
+    provider: "google",
+    models: [
+      // https://ai.google.dev/gemini-api/docs/models#gemini-2.5-pro
+      {
+        name: "gemini-2.5-pro",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536
+      },
+      // https://ai.google.dev/gemini-api/docs/models#gemini-2.5-flash
+      {
+        name: "gemini-2.5-flash",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536
+      },
+      // https://ai.google.dev/gemini-api/docs/models#gemini-2.5-flash-lite
+      {
+        name: "gemini-2.5-flash-lite",
+        contextWindow: 1048576,
+        maxOutputTokens: 65536
+      }
+    ]
+  },
+  {
+    provider: "openai",
+    models: [
+      // https://platform.openai.com/docs/models/gpt-5
+      {
+        name: "gpt-5",
+        contextWindow: 4e5,
+        maxOutputTokens: 128e3
+      },
+      // https://platform.openai.com/docs/models/gpt-5-mini
+      {
+        name: "gpt-5-mini",
+        contextWindow: 4e5,
+        maxOutputTokens: 128e3
+      },
+      // https://platform.openai.com/docs/models/gpt-5-nano
+      {
+        name: "gpt-5-nano",
+        contextWindow: 4e5,
+        maxOutputTokens: 128e3
+      },
+      // https://platform.openai.com/docs/models/gpt-5-chat-latest
+      {
+        name: "gpt-5-chat-latest",
+        contextWindow: 128e3,
+        maxOutputTokens: 16384
+      },
+      // https://platform.openai.com/docs/models/o4-mini
+      {
+        name: "o4-mini",
+        contextWindow: 2e5,
+        maxOutputTokens: 1e5
+      },
+      // https://platform.openai.com/docs/models/o3
+      {
+        name: "o3",
+        contextWindow: 2e5,
+        maxOutputTokens: 1e4
+      },
+      // https://platform.openai.com/docs/models/o3-mini
+      {
+        name: "o3-mini",
+        contextWindow: 2e5,
+        maxOutputTokens: 1e4
+      },
+      // https://platform.openai.com/docs/models/gpt-4.1
+      {
+        name: "gpt-4.1",
+        contextWindow: 1047576,
+        maxOutputTokens: 32768
+      }
+    ]
+  },
+  {
+    provider: "ollama",
+    models: [
+      // https://platform.openai.com/docs/models/gpt-oss-20b
+      {
+        name: "gpt-oss:20b",
+        contextWindow: 131072,
+        maxOutputTokens: 131072
+      },
+      // https://platform.openai.com/docs/models/gpt-oss-120b
+      {
+        name: "gpt-oss:120b",
+        contextWindow: 131072,
+        maxOutputTokens: 131072
+      },
+      // https://ai.google.dev/gemma/docs/core/model_card_3
+      {
+        name: "gemma3:1b",
+        contextWindow: 32e3,
+        maxOutputTokens: 32e3
+      },
+      // https://ai.google.dev/gemma/docs/core/model_card_3
+      {
+        name: "gemma3:4b",
+        contextWindow: 128e3,
+        maxOutputTokens: 128e3
+      },
+      // https://ai.google.dev/gemma/docs/core/model_card_3
+      {
+        name: "gemma3:12b",
+        contextWindow: 128e3,
+        maxOutputTokens: 128e3
+      },
+      // https://ai.google.dev/gemma/docs/core/model_card_3
+      {
+        name: "gemma3:27b",
+        contextWindow: 128e3,
+        maxOutputTokens: 128e3
+      }
+    ]
+  }
+];
+
+export { amazonBedrockProviderConfigSchema, anthropicProviderConfigSchema, attemptCompletion, azureOpenAiProviderConfigSchema, basePartSchema, callDelegate, callInteractiveTool, callTool, checkpointSchema, checkpointStatusSchema, completeRun, continueToNextStep, createEvent, defaultMaxRetries, defaultMaxSteps, defaultPerstackApiBaseUrl, defaultTemperature, defaultTimeout, envNameRegex, expertKeyRegex, expertMessageSchema, expertNameRegex, expertSchema, expertVersionRegex, fileBinaryPartSchema, fileInlinePartSchema, fileUrlPartSchema, finishToolCall, googleGenerativeAiProviderConfigSchema, imageBinaryPartSchema, imageInlinePartSchema, imageUrlPartSchema, instructionMessageSchema, interactiveSkillSchema, interactiveToolSchema, knownModels, maxApplicationNameLength, maxCheckpointToolCallIdLength, maxEnvNameLength, maxExpertDelegateItems, maxExpertDescriptionLength, maxExpertInstructionLength, maxExpertJobFileNameLength, maxExpertJobQueryLength, maxExpertKeyLength, maxExpertNameLength, maxExpertSkillItems, maxExpertTagItems, maxExpertVersionTagLength, maxOrganizationNameLength, maxSkillDescriptionLength, maxSkillEndpointLength, maxSkillInputJsonSchemaLength, maxSkillNameLength, maxSkillPickOmitItems, maxSkillRequiredEnvItems, maxSkillRuleLength, maxSkillToolItems, maxSkillToolNameLength, mcpSseSkillSchema, mcpStdioSkillSchema, messagePartSchema, messageSchema, ollamaProviderConfigSchema, openAiProviderConfigSchema, organizationNameRegex, packageWithVersionRegex, parseExpertKey, perstackConfigSchema, providerConfigSchema, providerNameSchema, resolveImageFile, resolvePdfFile, resolveThought, resolveToolResult, retry, runCommandInputSchema, runParamsSchema, skillSchema, startGeneration, startRun, stepSchema, stopRunByDelegate, stopRunByExceededMaxSteps, stopRunByInteractiveTool, tagNameRegex, textPartSchema, toolCallPartSchema, toolCallSchema, toolMessageSchema, toolResultPartSchema, toolResultSchema, urlSafeRegex, usageSchema, userMessageSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map