workflowskill 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,637 @@
+//#region src/types/index.d.ts
+/** The set of types available in workflow schemas. */
+type SchemaType = 'string' | 'int' | 'float' | 'boolean' | 'array' | 'object';
+/** Schema for a single field (workflow inputs, step inputs/outputs). */
+interface FieldSchema {
+  type: SchemaType;
+  /** Value: literal or $-expression. Replaces legacy `source`/`default`. */
+  value?: unknown;
+  /** For array types: describes element shape. */
+  items?: FieldSchema;
+  /** For object types: describes property shapes. */
+  properties?: Record<string, SchemaType | FieldSchema>;
+}
+/** Workflow-level input parameter declaration. `default` provides a fallback for optional inputs, overridable at runtime. */
+interface WorkflowInput {
+  type: SchemaType;
+  /** Default value for optional inputs. Overridable at runtime. */
+  default?: unknown;
+  /** For array types: describes element shape. */
+  items?: FieldSchema;
+  /** For object types: describes property shapes. */
+  properties?: Record<string, SchemaType | FieldSchema>;
+}
+/** Workflow-level output declaration. `value` is an expression resolving to the output from final runtime context. */
+type WorkflowOutput = FieldSchema;
+/** Step-level input declaration. `value` is either a literal or $-expression resolved at runtime. */
+type StepInput = FieldSchema;
+/** Step-level output declaration. `value` uses $result to map from raw executor result. */
+type StepOutput$1 = FieldSchema;
+/** Retry policy for a step. */
+interface RetryPolicy {
+  /** Maximum number of retry attempts. */
+  max: number;
+  /** Delay between retries (e.g., "1s", "500ms"). */
+  delay: string;
+  /** Backoff multiplier applied to delay after each retry. */
+  backoff: number;
+}
+/** Error handling strategy for a step. */
+type OnError = 'fail' | 'ignore';
+type StepType = 'tool' | 'llm' | 'transform' | 'conditional' | 'exit';
+/** Transform operation kinds. */
+type TransformOperation = 'filter' | 'map' | 'sort';
+/** Sort direction. */
+type SortDirection = 'asc' | 'desc';
+/** Exit statuses. */
+type ExitStatus = 'success' | 'failed';
+/** Common fields shared by all step types. */
+interface StepBase {
+  /** Unique identifier within the workflow. */
+  id: string;
+  /** Step type discriminator. */
+  type: StepType;
+  /** Human-readable description. */
+  description?: string;
+  /** What this step expects. */
+  inputs: Record<string, StepInput>;
+  /** What this step produces. */
+  outputs: Record<string, StepOutput$1>;
+  /** Guard condition: if false, the step is skipped and output is null. */
+  condition?: string;
+  /** Iterate over an array. $item and $index available inside the step. */
+  each?: string;
+  /** Inter-iteration delay when combined with each. Format: "1s", "500ms". */
+  delay?: string;
+  /** Error handling strategy. Default: fail. */
+  on_error?: OnError;
+  /** Retry policy. */
+  retry?: RetryPolicy;
+}
+/** Tool step: invokes a registered tool. */
+interface ToolStep extends StepBase {
+  type: 'tool';
+  /** Registered tool name. */
+  tool: string;
+}
+/** LLM step: calls a language model. */
+interface LLMStep extends StepBase {
+  type: 'llm';
+  /** Model identifier (optional, falls back to platform default). */
+  model?: string;
+  /** Prompt template with $-expression interpolation. */
+  prompt: string;
+  /** Structured output hint (optional). */
+  response_format?: Record<string, unknown>;
+}
+/** Transform step: filter, map, or sort data. */
+interface TransformFilterStep extends StepBase {
+  type: 'transform';
+  operation: 'filter';
+  /** Expression evaluated per item; items where true are kept. */
+  where: string;
+}
+interface TransformMapStep extends StepBase {
+  type: 'transform';
+  operation: 'map';
+  /** Object defining the output shape per item. Values may be expression references, literal primitives, or nested objects. */
+  expression: Record<string, unknown>;
+}
+interface TransformSortStep extends StepBase {
+  type: 'transform';
+  operation: 'sort';
+  /** Dot-notation path to the field to sort by. */
+  field: string;
+  /** Sort direction (default: asc). */
+  direction?: SortDirection;
+}
+type TransformStep = TransformFilterStep | TransformMapStep | TransformSortStep;
+/** Conditional step: branch based on a condition. */
+interface ConditionalStep extends StepBase {
+  type: 'conditional';
+  /** Expression to evaluate for branching. Overrides the common guard semantics. */
+  condition: string;
+  /** Step IDs to execute if condition is true. */
+  then: string[];
+  /** Step IDs to execute if condition is false (optional). */
+  else?: string[];
+}
+/** Exit step: terminates the workflow. */
+interface ExitStep extends StepBase {
+  type: 'exit';
+  /** Termination status. */
+  status: ExitStatus;
+  /** Final output: expression string, or object literal (values may be expressions). */
+  output?: string | Record<string, unknown>;
+}
+/** Union of all step types. */
+type Step = ToolStep | LLMStep | TransformStep | ConditionalStep | ExitStep;
+/** The complete parsed workflow definition. */
+interface WorkflowDefinition {
+  inputs: Record<string, WorkflowInput>;
+  outputs: Record<string, WorkflowOutput>;
+  steps: Step[];
+}
+/** SKILL.md frontmatter. */
+interface SkillFrontmatter {
+  name: string;
+  description: string;
+  [key: string]: unknown;
+}
+/** A fully parsed skill file: frontmatter + workflow definition. */
+interface ParsedSkill {
+  frontmatter: SkillFrontmatter;
+  workflow: WorkflowDefinition;
+}
+/** Token usage for an LLM step. */
+interface TokenUsage {
+  input: number;
+  output: number;
+}
+/** Retry tracking for a step that was retried. */
+interface RetryRecord {
+  /** Number of retry attempts (not counting the initial try). */
+  attempts: number;
+  /** Error messages from each failed attempt. */
+  errors: string[];
+}
+/** Status of a step in the run log. */
+type StepRunStatus = 'success' | 'failed' | 'skipped';
+/** A single step's record in the run log. */
+interface StepRecord {
+  /** The step's declared identifier. */
+  id: string;
+  /** Which executor ran this step. */
+  executor: StepType;
+  /** Execution outcome. */
+  status: StepRunStatus;
+  /** Why the step was skipped (if applicable). */
+  reason?: string;
+  /** Wall-clock time for this step in milliseconds. */
+  duration_ms: number;
+  /** Resolved inputs that were passed to the executor. */
+  inputs?: Record<string, unknown>;
+  /** Number of iterations (if each was used). */
+  iterations?: number;
+  /** Token counts (LLM steps only). */
+  tokens?: TokenUsage;
+  /** The step's output (may be truncated in logs). */
+  output?: unknown;
+  /** Error details if the step failed. */
+  error?: string;
+  /** Retry tracking (only present when retries occurred). */
+  retries?: RetryRecord;
+}
+/** Aggregate summary in the run log. */
+interface RunSummary {
+  steps_executed: number;
+  steps_skipped: number;
+  total_tokens: number;
+  total_duration_ms: number;
+}
+/** Final status of a workflow run. */
+type RunStatus = 'success' | 'failed';
+/** Structured error for pre-execution failures (parse or validate phases). */
+interface RunLogError {
+  /** Which phase the failure occurred in. */
+  phase: 'parse' | 'validate' | 'execute';
+  /** Human-readable error message. */
+  message: string;
+  /** Detailed per-path errors (if available). */
+  details?: Array<{
+    path: string;
+    message: string;
+  }>;
+}
+/** The complete run log produced by a workflow execution. */
+interface RunLog {
+  /** Unique run identifier. */
+  id: string;
+  /** Name of the workflow that was executed. */
+  workflow: string;
+  /** Final status. */
+  status: RunStatus;
+  /** Aggregate counts. */
+  summary: RunSummary;
+  /** ISO 8601 start timestamp. */
+  started_at: string;
+  /** ISO 8601 completion timestamp. */
+  completed_at: string;
+  /** Total wall-clock time in milliseconds. */
+  duration_ms: number;
+  /** The workflow inputs that were provided. */
+  inputs: Record<string, unknown>;
+  /** Ordered array of step records. */
+  steps: StepRecord[];
+  /** The workflow outputs that were produced. */
+  outputs: Record<string, unknown>;
+  /** Structured error for pre-execution failures. Present only when status is 'failed' due to parse/validate/execute errors. */
+  error?: RunLogError;
+}
+/** Discriminated union of events emitted by the runtime during workflow execution. */
+type RuntimeEvent = {
+  type: 'workflow_start';
+  workflow: string;
+  totalSteps: number;
+} | {
+  type: 'step_start';
+  stepId: string;
+  stepType: StepType;
+  tool?: string;
+} | {
+  type: 'step_complete';
+  stepId: string;
+  status: StepRunStatus;
+  duration_ms: number;
+  tokens?: TokenUsage;
+  iterations?: number;
+} | {
+  type: 'step_skip';
+  stepId: string;
+  reason: string;
+} | {
+  type: 'step_retry';
+  stepId: string;
+  attempt: number;
+  error: string;
+} | {
+  type: 'step_error';
+  stepId: string;
+  error: string;
+  onError: OnError;
+} | {
+  type: 'each_progress';
+  stepId: string;
+  current: number;
+  total: number;
+} | {
+  type: 'workflow_complete';
+  status: RunStatus;
+  duration_ms: number;
+  summary: RunSummary;
+};
+/** Minimal JSON Schema type for tool parameter/output descriptions. */
+interface JsonSchema {
+  type?: string;
+  description?: string;
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  items?: JsonSchema;
+  enum?: unknown[];
+  [key: string]: unknown;
+}
+/** Describes a tool's name, purpose, and parameter schemas. */
+interface ToolDescriptor {
+  name: string;
+  description: string;
+  inputSchema?: JsonSchema;
+  outputSchema?: JsonSchema;
+}
+/** Result from a tool invocation. */
+interface ToolResult {
+  output: unknown;
+  error?: string;
+}
+/** Tool adapter interface for invoking registered tools. */
+interface ToolAdapter {
+  invoke(toolName: string, args: Record<string, unknown>): Promise<ToolResult>;
+  /** Check whether a tool is available. */
+  has(toolName: string): boolean;
+  /** List all available tools with their metadata. Optional for backward compatibility. */
+  list?(): ToolDescriptor[];
+}
+/** Result from an LLM call. */
+interface LLMResult {
+  text: string;
+  tokens: TokenUsage;
+}
+/** LLM adapter interface for calling language models. */
+interface LLMAdapter {
+  call(model: string | undefined, prompt: string, responseFormat?: Record<string, unknown>): Promise<LLMResult>;
+}
+/** Runtime context available during step execution. */
+interface RuntimeContext {
+  /** Workflow-level inputs. */
+  inputs: Record<string, unknown>;
+  /** Outputs from completed steps, keyed by step ID. */
+  steps: Record<string, {
+    output: unknown;
+  }>;
+  /** Current item when inside an `each` loop. */
+  item?: unknown;
+  /** Current index when inside an `each` loop. */
+  index?: number;
+  /** Raw executor result, set during step output value mapping. */
+  result?: unknown;
+}
+/** A single validation error with context. */
+interface ValidationError {
+  /** Which step or field the error relates to. */
+  path: string;
+  /** Human-readable error message. */
+  message: string;
+}
+/** Result of workflow validation. */
+interface ValidationResult {
+  valid: boolean;
+  errors: ValidationError[];
+}
+//#endregion
+//#region src/parser/index.d.ts
+/** Error thrown when parsing fails. Includes structured details. */
+declare class ParseError extends Error {
+  readonly details: ParseErrorDetail[];
+  constructor(message: string, details?: ParseErrorDetail[]);
+}
+interface ParseErrorDetail {
+  path: string;
+  message: string;
+}
+/**
+ * Parse a raw YAML string into a validated WorkflowDefinition.
+ * Use this when you already have the YAML content (e.g., from extractWorkflowBlock).
+ */
+declare function parseWorkflowYaml(yaml: string): WorkflowDefinition;
+/**
+ * Parse a SKILL.md file content into a fully typed ParsedSkill.
+ * Extracts frontmatter and workflow block, validates both.
+ */
+declare function parseSkillMd(content: string): ParsedSkill;
+/**
+ * Parse just the workflow block from SKILL.md content.
+ * Useful when you only need the workflow definition without frontmatter.
+ */
+declare function parseWorkflowFromMd(content: string): WorkflowDefinition;
+//#endregion
+//#region src/expression/lexer.d.ts
+declare class LexError extends Error {
+  readonly position: number;
+  constructor(message: string, position: number);
+}
+//#endregion
+//#region src/expression/parser.d.ts
+declare class ParseExprError extends Error {
+  readonly position: number;
+  constructor(message: string, position: number);
+}
+//#endregion
+//#region src/expression/evaluator.d.ts
+declare class EvalError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/expression/index.d.ts
+/**
+ * Resolve a single expression string against a runtime context.
+ * Used for source, condition, where, each, and output fields.
+ * Example: "$steps.fetch.output.messages.length >= 5"
+ */
+declare function resolveExpression(expr: string, context: RuntimeContext): unknown;
+/**
+ * Interpolate $-references in a prompt template string.
+ * Only resolves references and property access (no operators).
+ * Objects/arrays are serialized as JSON. Null → empty string.
+ *
+ * Example: "Score this email: $steps.fetch.output.subject"
+ */
+declare function interpolatePrompt(template: string, context: RuntimeContext): string;
+//#endregion
+//#region src/validator/index.d.ts
+/**
+ * Validate a workflow definition before execution.
+ * Checks structural correctness, reference graph, type compatibility, and tool availability.
+ * Returns all errors found — does not fail fast.
+ */
+declare function validateWorkflow(workflow: WorkflowDefinition, toolAdapter?: ToolAdapter): ValidationResult;
+interface ValidateWorkflowSkillOptions {
+  content: string;
+  toolAdapter?: ToolAdapter;
+}
+interface ValidateWorkflowSkillResult {
+  valid: boolean;
+  errors: Array<{
+    path: string;
+    message: string;
+  }>;
+  name?: string;
+  stepCount?: number;
+  stepTypes?: string[];
+}
+/**
+ * Parse content and validate the workflow in one synchronous call.
+ * Matches the shape of the plugin's ValidateResult exactly.
+ */
+declare function validateWorkflowSkill(options: ValidateWorkflowSkillOptions): ValidateWorkflowSkillResult;
+//#endregion
+//#region src/adapters/mock-tool-adapter.d.ts
+/** Handler function for a registered mock tool. */
+type ToolHandler = (args: Record<string, unknown>) => ToolResult | Promise<ToolResult>;
+declare class MockToolAdapter implements ToolAdapter {
+  private tools;
+  /** Register a tool handler with optional descriptor metadata. */
+  register(toolName: string, handler: ToolHandler, descriptor?: Omit<ToolDescriptor, 'name'>): void;
+  has(toolName: string): boolean;
+  /** List all registered tools with their descriptors. */
+  list(): ToolDescriptor[];
+  invoke(toolName: string, args: Record<string, unknown>): Promise<ToolResult>;
+}
+//#endregion
+//#region src/adapters/mock-llm-adapter.d.ts
+type LLMHandler = (model: string | undefined, prompt: string, responseFormat?: Record<string, unknown>) => LLMResult | Promise<LLMResult>;
+declare class MockLLMAdapter implements LLMAdapter {
+  private handler;
+  constructor(handler?: LLMHandler);
+  call(model: string | undefined, prompt: string, responseFormat?: Record<string, unknown>): Promise<LLMResult>;
+}
+//#endregion
+//#region src/adapters/anthropic-llm-adapter.d.ts
+declare class AnthropicLLMAdapter implements LLMAdapter {
+  private client;
+  constructor(apiKey: string);
+  call(model: string | undefined, prompt: string, responseFormat?: Record<string, unknown>): Promise<LLMResult>;
+}
+//#endregion
+//#region src/config/index.d.ts
+/** Google OAuth2 credentials for Gmail/Sheets tools. */
+interface GoogleCredentials {
+  clientId: string;
+  clientSecret: string;
+  refreshToken: string;
+}
+/** WorkflowSkill configuration. */
+interface WorkflowSkillConfig {
+  anthropicApiKey?: string;
+  googleCredentials?: GoogleCredentials;
+}
+/**
+ * Load configuration from environment variables, with .env fallback.
+ * Environment variables take precedence over .env file values.
+ *
+ * .env search order:
+ * 1. Explicit `cwd` parameter (for tests)
+ * 2. Package root (found by walking up from this module)
+ * 3. process.cwd()
+ */
+declare function loadConfig(cwd?: string): WorkflowSkillConfig;
+//#endregion
+//#region src/dev-tools/dev-tool-adapter.d.ts
+declare class DevToolAdapter implements ToolAdapter {
+  private tools;
+  private register;
+  has(toolName: string): boolean;
+  list(): ToolDescriptor[];
+  invoke(toolName: string, args: Record<string, unknown>): Promise<ToolResult>;
+  /**
+   * Create a DevToolAdapter with all available tools registered.
+   * Google tools are only registered if credentials are provided.
+   */
+  static create(config: WorkflowSkillConfig): Promise<DevToolAdapter>;
+}
+//#endregion
+//#region src/executor/types.d.ts
+/** Additional context attached to a step execution error. */
+interface StepErrorContext {
+  /** Tool name if the error came from a tool step. */
+  tool?: string;
+  /** Expression string if the error came from expression resolution. */
+  expression?: string;
+}
+/** Error thrown by step executors. */
+declare class StepExecutionError extends Error {
+  /** Whether this error is retriable (network errors, rate limits, transient API failures). */
+  readonly retriable: boolean;
+  /** Optional context about the error source. */
+  readonly context?: StepErrorContext | undefined;
+  constructor(message: string, /** Whether this error is retriable (network errors, rate limits, transient API failures). */
+
+  retriable?: boolean, /** Optional context about the error source. */
+
+  context?: StepErrorContext | undefined);
+}
+/** Result from a standard step execution (tool, llm, transform). */
+interface StepOutput {
+  output: unknown;
+  tokens?: TokenUsage;
+}
+/** Result from a conditional step execution. */
+interface ConditionalOutput {
+  branch: 'then' | 'else' | null;
+  stepIds: string[];
+}
+/** Result from an exit step execution. */
+interface ExitOutput {
+  status: ExitStatus;
+  output: unknown;
+}
+//#endregion
+//#region src/executor/transform.d.ts
+/**
+ * Execute a transform step.
+ * Returns an object with the first declared output key mapped to the transformed array.
+ */
+declare function executeTransform(step: TransformStep, resolvedInputs: Record<string, unknown>, context: RuntimeContext): Record<string, unknown>;
+//#endregion
+//#region src/executor/conditional.d.ts
+/**
+ * Execute a conditional step.
+ * Evaluates the condition expression and returns the branch to execute.
+ * The runtime is responsible for executing the branch steps.
+ */
+declare function executeConditional(step: ConditionalStep, context: RuntimeContext): ConditionalOutput;
+//#endregion
+//#region src/executor/exit.d.ts
+/**
+ * Execute an exit step.
+ * Output can be:
+ * - A string expression: resolved against context
+ * - An object literal: each string value starting with $ is resolved, others kept as-is
+ * - Undefined: null output
+ */
+declare function executeExit(step: ExitStep, context: RuntimeContext): ExitOutput;
+//#endregion
+//#region src/executor/tool.d.ts
+/**
+ * Execute a tool step.
+ * Passes resolved inputs as the tool's arguments. Returns the tool's response.
+ * The runtime does not interpret the response (per spec).
+ */
+declare function executeTool(step: ToolStep, resolvedInputs: Record<string, unknown>, toolAdapter: ToolAdapter): Promise<StepOutput>;
+//#endregion
+//#region src/executor/llm.d.ts
+/**
+ * Execute an LLM step.
+ * Interpolates $-references in the prompt, calls the model, and returns the response.
+ * The response_format field is passed as a hint but not enforced (per spec).
+ * If the response is valid JSON, it's parsed; otherwise returned as text.
+ */
+declare function executeLLM(step: LLMStep, _resolvedInputs: Record<string, unknown>, context: RuntimeContext, llmAdapter: LLMAdapter): Promise<StepOutput>;
+//#endregion
+//#region src/executor/index.d.ts
+/** Discriminated result from dispatching a step. */
+type DispatchResult = {
+  kind: 'output';
+  output: unknown;
+  tokens?: TokenUsage;
+} | {
+  kind: 'branch';
+  branch: 'then' | 'else' | null;
+  stepIds: string[];
+} | {
+  kind: 'exit';
+  status: ExitStatus;
+  output: unknown;
+};
+/**
+ * Dispatch a step to the appropriate executor.
+ * The runtime calls this for each step in the execution loop.
+ */
+declare function dispatch(step: Step, resolvedInputs: Record<string, unknown>, context: RuntimeContext, toolAdapter: ToolAdapter, llmAdapter: LLMAdapter): Promise<DispatchResult>;
+//#endregion
+//#region src/runtime/index.d.ts
+declare class WorkflowExecutionError extends Error {
+  readonly validationErrors?: ValidationError[] | undefined;
+  constructor(message: string, validationErrors?: ValidationError[] | undefined);
+}
+/**
+ * Build a minimal RunLog for a pre-execution failure (parse or validate phase).
+ * Every run attempt — even those that fail before execution begins — produces a structured artifact.
+ */
+declare function buildFailedRunLog(workflowName: string, error: RunLogError, startedAt?: Date): RunLog;
+interface RunOptions {
+  workflow: WorkflowDefinition;
+  inputs?: Record<string, unknown>;
+  toolAdapter: ToolAdapter;
+  llmAdapter: LLMAdapter;
+  workflowName?: string;
+  /** Optional callback for live progress events during execution. */
+  onEvent?: (event: RuntimeEvent) => void;
+}
+/**
+ * Execute a workflow and produce a run log.
+ * Phase 1: Validate the workflow definition.
+ * Phase 2: Execute steps in declaration order following the 8-step lifecycle.
+ */
+declare function runWorkflow(options: RunOptions): Promise<RunLog>;
+interface RunWorkflowSkillOptions {
+  /** SKILL.md content or raw workflow YAML block. */
+  content: string;
+  inputs?: Record<string, unknown>;
+  toolAdapter: ToolAdapter;
+  llmAdapter: LLMAdapter;
+  /** Fallback name used when content has no frontmatter. Defaults to 'inline'. */
+  workflowName?: string;
+  onEvent?: (event: RuntimeEvent) => void;
+}
+/**
+ * Parse content and execute the workflow in one call. Never throws.
+ * Empty or unparseable content → failed RunLog (phase: 'parse').
+ * Unexpected execution exception → failed RunLog (phase: 'execute').
+ * Validation failures are handled internally by runWorkflow.
+ */
+declare function runWorkflowSkill(options: RunWorkflowSkillOptions): Promise<RunLog>;
+//#endregion
+//#region src/skill/index.d.ts
+declare const AUTHORING_SKILL: string;
+//#endregion
+export { AUTHORING_SKILL, AnthropicLLMAdapter, type ConditionalOutput, ConditionalStep, DevToolAdapter, type DispatchResult, EvalError, type ExitOutput, ExitStatus, ExitStep, FieldSchema, type GoogleCredentials, JsonSchema, LLMAdapter, type LLMHandler, LLMResult, LLMStep, LexError, MockLLMAdapter, MockToolAdapter, OnError, ParseError, type ParseErrorDetail, ParseExprError, ParsedSkill, RetryPolicy, RetryRecord, RunLog, RunLogError, type RunOptions, RunStatus, RunSummary, type RunWorkflowSkillOptions, RuntimeContext, RuntimeEvent, SchemaType, SkillFrontmatter, SortDirection, Step, StepBase, type StepErrorContext, StepExecutionError, StepInput, type StepOutput, StepRecord, StepRunStatus, StepType, TokenUsage, ToolAdapter, ToolDescriptor, type ToolHandler, ToolResult, ToolStep, TransformFilterStep, TransformMapStep, TransformOperation, TransformSortStep, TransformStep, type ValidateWorkflowSkillOptions, type ValidateWorkflowSkillResult, ValidationError, ValidationResult, WorkflowDefinition, WorkflowExecutionError, WorkflowInput, WorkflowOutput, type WorkflowSkillConfig, buildFailedRunLog, dispatch, executeConditional, executeExit, executeLLM, executeTool, executeTransform, interpolatePrompt, loadConfig, parseSkillMd, parseWorkflowFromMd, parseWorkflowYaml, resolveExpression, runWorkflow, runWorkflowSkill, validateWorkflow, validateWorkflowSkill };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types/index.ts","../src/parser/index.ts","../src/expression/lexer.ts","../src/expression/parser.ts","../src/expression/evaluator.ts","../src/expression/index.ts","../src/validator/index.ts","../src/adapters/mock-tool-adapter.ts","../src/adapters/mock-llm-adapter.ts","../src/adapters/anthropic-llm-adapter.ts","../src/config/index.ts","../src/dev-tools/dev-tool-adapter.ts","../src/executor/types.ts","../src/executor/transform.ts","../src/executor/conditional.ts","../src/executor/exit.ts","../src/executor/tool.ts","../src/executor/llm.ts","../src/executor/index.ts","../src/runtime/index.ts","../src/skill/index.ts"],"mappings":"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"}