@fevex/core 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/index-CqOjvtQ9.d.mts

@@ -0,0 +1,132 @@
+import { t as ExactDefinition } from "./exact-definition-NHBBFlFR.mjs";
+import { f as RunId, g as ToolSpec, h as ToolEventSource, l as JsonValue, o as ExecutionContext, s as JsonObject } from "./types-CuoRx12Q.mjs";
+import { i as SandboxCapabilities, r as Sandbox } from "./index-CrOId2px.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/tools/tool.d.ts
+interface ToolExecutionContext {
+  runId: RunId;
+  toolCallId: string;
+  attempt: number;
+  idempotencyKey: string;
+  getCredential(name: string): Promise<string>;
+  sandbox?: Sandbox;
+  context?: ExecutionContext;
+  signal?: AbortSignal;
+}
+type ToolRisk = 'read' | 'write' | 'sensitive' | 'destructive';
+type ToolApproval = 'never' | 'required';
+type ToolIdempotency = 'none' | 'keyed';
+interface ToolRetryPolicy {
+  maxAttempts: number;
+  backoffMs: number;
+  maxBackoffMs?: number;
+}
+interface ToolDefinition<TInput = unknown, TOutput = unknown> {
+  name: string;
+  label?: string;
+  description?: string;
+  inputSchema?: StandardSchemaV1<unknown, TInput>;
+  outputSchema?: StandardSchemaV1<unknown, TOutput>;
+  inputJsonSchema?: JsonObject;
+  outputJsonSchema?: JsonObject;
+  risk?: ToolRisk;
+  approval?: ToolApproval;
+  idempotency?: ToolIdempotency;
+  retry?: ToolRetryPolicy;
+  credentials?: string[];
+  sandbox?: SandboxCapabilities;
+  source?: ToolEventSource;
+  resolve?: (context?: ToolProviderContext) => Promise<ToolProviderTool | undefined>;
+  execute(input: TInput, context: ToolExecutionContext): TOutput | Promise<TOutput>;
+}
+type ToolWithSchemas<TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1> = Omit<ToolDefinition<StandardSchemaV1.InferOutput<TInputSchema>, StandardSchemaV1.InferOutput<TOutputSchema>>, 'inputSchema' | 'outputSchema'> & {
+  inputSchema: TInputSchema;
+  outputSchema: TOutputSchema;
+};
+type ToolWithInputSchema<TInputSchema extends StandardSchemaV1> = Omit<ToolDefinition<StandardSchemaV1.InferOutput<TInputSchema>, unknown>, 'inputSchema'> & {
+  inputSchema: TInputSchema;
+};
+declare function defineTool<TInputSchema extends StandardSchemaV1, TOutputSchema extends StandardSchemaV1, TDefinition extends ToolWithSchemas<TInputSchema, TOutputSchema>>(tool: ToolWithSchemas<TInputSchema, TOutputSchema> & ExactDefinition<TDefinition, ToolWithSchemas<TInputSchema, TOutputSchema>>): TDefinition;
+declare function defineTool<TInputSchema extends StandardSchemaV1, TDefinition extends ToolWithInputSchema<TInputSchema>>(tool: ToolWithInputSchema<TInputSchema> & ExactDefinition<TDefinition, ToolWithInputSchema<TInputSchema>>): TDefinition;
+declare function defineTool<TDefinition extends ToolDefinition>(tool: ToolDefinition & ExactDefinition<TDefinition, ToolDefinition>): TDefinition;
+declare function toToolSpec(tool: ToolDefinition, inputSchema?: JsonObject): ToolSpec;
+type ToolResult = JsonValue;
+//#endregion
+//#region src/tools/connection.d.ts
+interface ToolProviderContext {
+  runId?: RunId;
+  toolCallId?: string;
+  attempt?: number;
+  idempotencyKey?: string;
+  context?: ExecutionContext;
+  signal?: AbortSignal;
+}
+interface ToolProviderTool {
+  name: string;
+  label?: string;
+  description?: string;
+  inputSchema?: JsonObject;
+  outputSchema?: JsonObject;
+}
+interface ToolProvider {
+  kind?: string;
+  listTools(context?: ToolProviderContext): Promise<ToolProviderTool[]>;
+  callTool(name: string, input: JsonValue, context: ToolProviderContext): JsonValue | Promise<JsonValue>;
+  close?(): Promise<void>;
+}
+type IntegrationErrorCategory = 'auth' | 'validation' | 'network' | 'remote' | 'timeout';
+/** Safe, provider-neutral error surfaced by connection adapters. */
+declare class IntegrationError extends Error {
+  readonly code: string;
+  readonly category: IntegrationErrorCategory;
+  readonly retryable: boolean;
+  readonly safeMessage: string;
+  readonly name = "IntegrationError";
+  constructor(code: string, category: IntegrationErrorCategory, retryable: boolean, safeMessage: string, options?: ErrorOptions & {
+    source?: ToolEventSource;
+  });
+  readonly source?: ToolEventSource;
+}
+interface ConnectionToolPolicy {
+  label?: string;
+  description?: string;
+  inputSchema?: JsonObject;
+  outputSchema?: JsonObject;
+  risk?: ToolRisk;
+  approval?: ToolApproval;
+  idempotency?: ToolIdempotency;
+  retry?: ToolRetryPolicy;
+  credentials?: string[];
+}
+interface ConnectionDefinition {
+  name: string;
+  provider: ToolProvider;
+  allowlist?: readonly string[];
+  tools?: {
+    allow: readonly string[];
+  } | Record<string, ConnectionToolPolicy>;
+  timeoutMs?: number;
+}
+declare function defineConnection<TDefinition extends ConnectionDefinition>(connection: TDefinition): TDefinition;
+//#endregion
+//#region src/tools/json-schema-profile.d.ts
+declare const FEVEX_JSON_SCHEMA_PROFILE_VERSION = "1";
+interface FevexJsonSchemaProfileLimits {
+  maxBytes?: number;
+  maxDepth?: number;
+  maxNodes?: number;
+  maxProperties?: number;
+}
+interface FevexJsonSchemaProfileOptions {
+  rootDocument?: JsonObject;
+  requireRootObject?: boolean;
+  limits?: FevexJsonSchemaProfileLimits;
+}
+interface FevexJsonSchemaValidator {
+  schema: JsonObject;
+  validate(value: unknown, path?: string): JsonValue;
+}
+declare function validateFevexJsonSchemaProfile(schema: JsonObject, options?: FevexJsonSchemaProfileOptions): JsonObject;
+declare function compileFevexJsonSchema(schema: JsonObject, options?: FevexJsonSchemaProfileOptions): FevexJsonSchemaValidator;
+//#endregion
+export { toToolSpec as C, defineTool as S, ToolExecutionContext as _, compileFevexJsonSchema as a, ToolRetryPolicy as b, ConnectionToolPolicy as c, ToolProvider as d, ToolProviderContext as f, ToolDefinition as g, ToolApproval as h, FevexJsonSchemaValidator as i, IntegrationError as l, defineConnection as m, FevexJsonSchemaProfileLimits as n, validateFevexJsonSchemaProfile as o, ToolProviderTool as p, FevexJsonSchemaProfileOptions as r, ConnectionDefinition as s, FEVEX_JSON_SCHEMA_PROFILE_VERSION as t, IntegrationErrorCategory as u, ToolIdempotency as v, ToolRisk as x, ToolResult as y };

package/dist/index-CrOId2px.d.mts

@@ -0,0 +1,66 @@
+import { f as RunId, l as JsonValue, o as ExecutionContext } from "./types-CuoRx12Q.mjs";
+//#region src/sandbox/sandbox.d.ts
+interface SandboxCapabilities {
+  process?: {
+    commands?: readonly string[];
+    timeoutMs?: number;
+  };
+  filesystem?: {
+    cwd?: string;
+    read?: readonly string[];
+    write?: readonly string[];
+  };
+  network?: false | {
+    allow?: readonly string[];
+  };
+  resources?: {
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+  };
+}
+interface SandboxRunRequest {
+  command: string;
+  args?: readonly string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  input?: string;
+  timeoutMs?: number;
+  maxOutputBytes?: number;
+  capabilities?: SandboxCapabilities;
+  runId?: RunId;
+  toolCallId?: string;
+  attempt?: number;
+  idempotencyKey?: string;
+  context?: ExecutionContext;
+  signal?: AbortSignal;
+}
+interface SandboxRunResult {
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+  durationMs: number;
+  timedOut: boolean;
+}
+interface Sandbox {
+  run(request: SandboxRunRequest): Promise<SandboxRunResult>;
+}
+declare class SandboxError extends Error {
+  readonly code: string;
+  readonly safeMessage: string;
+  readonly name = "SandboxError";
+  constructor(code: string, safeMessage: string, options?: ErrorOptions);
+}
+declare function sandboxResultToJson(result: SandboxRunResult): JsonValue;
+//#endregion
+//#region src/sandbox/local-sandbox.d.ts
+interface LocalSandboxOptions {
+  rootDir: string;
+  commands: readonly string[];
+  defaultTimeoutMs?: number;
+  maxOutputBytes?: number;
+  env?: Record<string, string>;
+}
+/** Creates a subprocess sandbox restricted to a root directory and command allowlist. */
+declare function createLocalSandbox(options: LocalSandboxOptions): Sandbox;
+//#endregion
+export { SandboxError as a, sandboxResultToJson as c, SandboxCapabilities as i, createLocalSandbox as n, SandboxRunRequest as o, Sandbox as r, SandboxRunResult as s, LocalSandboxOptions as t };

package/dist/index-DeXUtyd9.d.mts

@@ -0,0 +1,70 @@
+import { l as JsonValue, o as ExecutionContext, s as JsonObject } from "./types-CuoRx12Q.mjs";
+import { M as SessionId } from "./index-Dx_LotWZ.mjs";
+//#region src/knowledge/knowledge.d.ts
+/** Runtime context supplied to knowledge providers and memory stores. */
+interface KnowledgeContext {
+  agentName: string;
+  input: string;
+  sessionId: SessionId;
+  context?: ExecutionContext;
+  signal?: AbortSignal;
+}
+interface ContextBlock {
+  id: string;
+  content: string;
+  metadata?: JsonObject;
+}
+interface ContextProvider {
+  name: string;
+  read(context: KnowledgeContext): Promise<ContextBlock[]>;
+}
+interface MemoryQuery {
+  query: string;
+  limit?: number;
+  agentName?: string;
+  sessionId?: SessionId;
+  namespace?: string;
+  actor?: ExecutionContext['actor'];
+}
+interface MemoryWrite {
+  content: string;
+  agentName?: string;
+  sessionId?: SessionId;
+  namespace?: string;
+  actor?: ExecutionContext['actor'];
+  metadata?: JsonObject;
+}
+interface MemoryRecord extends MemoryWrite {
+  id: string;
+  createdAt: string;
+}
+interface MemoryStore {
+  search(query: MemoryQuery, context: KnowledgeContext): Promise<MemoryRecord[]>;
+  write(record: MemoryWrite, context: KnowledgeContext): Promise<MemoryRecord>;
+}
+interface SkillDefinition {
+  name: string;
+  instructions: string;
+  resources?: Array<string | JsonValue | {
+    id?: string;
+    content: string | JsonValue;
+    metadata?: JsonObject;
+  }>;
+}
+declare function defineContextProvider<T extends ContextProvider>(provider: T): T;
+declare function defineSkill(skill: SkillDefinition): ContextProvider;
+declare function createMemoryContextProvider(options: {
+  name?: string;
+  store: MemoryStore;
+  limit?: number;
+}): ContextProvider;
+//#endregion
+//#region src/knowledge/in-memory-memory-store.d.ts
+/** Volatile keyword-search memory store for tests and local development. */
+declare class InMemoryMemoryStore implements MemoryStore {
+  #private;
+  search(query: MemoryQuery, context: KnowledgeContext): Promise<MemoryRecord[]>;
+  write(record: MemoryWrite, context: KnowledgeContext): Promise<MemoryRecord>;
+}
+//#endregion
+export { MemoryQuery as a, MemoryWrite as c, defineContextProvider as d, defineSkill as f, KnowledgeContext as i, SkillDefinition as l, ContextBlock as n, MemoryRecord as o, ContextProvider as r, MemoryStore as s, InMemoryMemoryStore as t, createMemoryContextProvider as u };

package/dist/index-DviHtsLo.d.mts

@@ -0,0 +1,58 @@
+import { t as ExactDefinition } from "./exact-definition-NHBBFlFR.mjs";
+import { f as RunId, l as JsonValue, o as ExecutionContext, s as JsonObject } from "./types-CuoRx12Q.mjs";
+import { D as RunRequest, M as SessionId, O as RunResult, n as AgentLimits } from "./index-Dx_LotWZ.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/workflows/workflow.d.ts
+/** Context shared with workflow steps and compensation handlers. */
+interface WorkflowStepContext {
+  runId: RunId;
+  sessionId: SessionId;
+  stepId: string;
+  context?: ExecutionContext;
+  signal: AbortSignal;
+}
+interface WorkflowStepOptions<TResult = unknown> {
+  compensate?(result: TResult, context: WorkflowStepContext): void | Promise<void>;
+  /** Metadata persisted with the step and its lifecycle events. */
+  metadata?: JsonObject;
+}
+type WorkflowAgentResult<TOutput = unknown> = Omit<RunResult<TOutput>, 'events'>;
+interface WorkflowEventResult<TPayload extends JsonValue = JsonValue> {
+  payload?: TPayload;
+  actor?: NonNullable<ExecutionContext['actor']>;
+  receivedAt: string;
+}
+interface WorkflowEventDefinition<TPayload extends JsonValue = JsonValue> {
+  payloadSchema?: StandardSchemaV1<unknown, TPayload>;
+  requireActor?: boolean;
+}
+interface WorkflowStep {
+  agent<TInput = unknown, TOutput = unknown>(stepId: string, agentName: string, request: RunRequest<TInput, TOutput>, options?: WorkflowStepOptions<WorkflowAgentResult<TOutput>>): Promise<WorkflowAgentResult<TOutput>>;
+  parallel<TTasks extends Record<string, () => Promise<unknown>>>(stepId: string, tasks: TTasks, options?: WorkflowStepOptions<{ [TKey in keyof TTasks]: Awaited<ReturnType<TTasks[TKey]>>; }>): Promise<{ [TKey in keyof TTasks]: Awaited<ReturnType<TTasks[TKey]>>; }>;
+  waitUntil(stepId: string, resumeAt: string | Date): Promise<void>;
+  waitForEvent<TPayload extends JsonValue = JsonValue>(stepId: string, eventName: string): Promise<WorkflowEventResult<TPayload>>;
+}
+interface WorkflowDefinition<TInput = unknown, TOutput = unknown> {
+  name: string;
+  inputSchema?: StandardSchemaV1<unknown, TInput>;
+  outputSchema?: StandardSchemaV1<unknown, TOutput>;
+  events?: Record<string, WorkflowEventDefinition>;
+  limits?: AgentLimits;
+  /**
+   * Semantic version of `run`, defaults to `"1"`.
+   *
+   * A paused run only resumes against the same version. Bump it whenever a
+   * change to `run` — or to anything `run` calls — would make replaying an
+   * in-flight run incorrect: reordered steps, a reused `stepId` that now means
+   * something else, or a changed business rule.
+   *
+   * The runtime cannot infer this. Hashing the source of `run` would break on
+   * every minified redeploy while still missing changes in the functions `run`
+   * closes over, so the decision belongs to the author.
+   */
+  version?: string;
+  run(step: WorkflowStep, input: TInput): TOutput | Promise<TOutput>;
+}
+declare function defineWorkflow<T extends WorkflowDefinition>(workflow: ExactDefinition<T, WorkflowDefinition>): T;
+//#endregion
+export { WorkflowStep as a, defineWorkflow as c, WorkflowEventResult as i, WorkflowDefinition as n, WorkflowStepContext as o, WorkflowEventDefinition as r, WorkflowStepOptions as s, WorkflowAgentResult as t };