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

package/dist/tools/index.mjs

@@ -1,4 +1,224 @@
-//#region src/tools/index.ts
+//#region src/tools/connection.ts
+/** Safe, provider-neutral error surfaced by connection adapters. */
+var IntegrationError = class extends Error {
+	code;
+	category;
+	retryable;
+	safeMessage;
+	name = "IntegrationError";
+	constructor(code, category, retryable, safeMessage, options) {
+		super(safeMessage, options);
+		this.code = code;
+		this.category = category;
+		this.retryable = retryable;
+		this.safeMessage = safeMessage;
+		this.source = options?.source;
+	}
+	source;
+};
+function defineConnection(connection) {
+	return connection;
+}
+//#endregion
+//#region src/tools/json-schema-profile.ts
+const FEVEX_JSON_SCHEMA_PROFILE_VERSION = "1";
+const DEFAULT_LIMITS = {
+	maxBytes: 64e3,
+	maxDepth: 32,
+	maxNodes: 1e3,
+	maxProperties: 200
+};
+const KEYWORDS = /* @__PURE__ */ new Set([
+	"$defs",
+	"$ref",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"const",
+	"default",
+	"description",
+	"enum",
+	"items",
+	"maxItems",
+	"maxLength",
+	"maximum",
+	"minItems",
+	"minLength",
+	"minimum",
+	"oneOf",
+	"properties",
+	"required",
+	"title",
+	"type"
+]);
+const DEFERRED = /* @__PURE__ */ new Set([
+	"dependentSchemas",
+	"format",
+	"if",
+	"not",
+	"pattern",
+	"then",
+	"else",
+	"unevaluatedProperties"
+]);
+function validateFevexJsonSchemaProfile(schema, options = {}) {
+	const limits = {
+		...DEFAULT_LIMITS,
+		...options.limits
+	};
+	if (JSON.stringify(schema).length > limits.maxBytes) throw new TypeError(`JSON Schema exceeds maxBytes limit of ${limits.maxBytes}`);
+	visitSchema(schema, options.rootDocument ?? schema, options.requireRootObject ?? false, limits, { nodes: 0 }, [], 0);
+	return schema;
+}
+function compileFevexJsonSchema(schema, options = {}) {
+	validateFevexJsonSchemaProfile(schema, options);
+	const rootDocument = options.rootDocument ?? schema;
+	return {
+		schema,
+		validate(value, path = "$") {
+			validateValue(schema, rootDocument, value, path, []);
+			return toJsonValue(value, `${path} must be JSON-serializable`);
+		}
+	};
+}
+function visitSchema(schema, rootDocument, requireRootObject, limits, stats, refs, depth) {
+	stats.nodes += 1;
+	if (stats.nodes > limits.maxNodes) throw new TypeError(`JSON Schema exceeds maxNodes limit of ${limits.maxNodes}`);
+	if (depth > limits.maxDepth) throw new TypeError(`JSON Schema exceeds maxDepth limit of ${limits.maxDepth}`);
+	for (const key of Object.keys(schema)) if (DEFERRED.has(key) || !KEYWORDS.has(key)) throw new TypeError(`JSON Schema keyword "${key}" is not supported`);
+	if (requireRootObject && schema.type !== "object" && !schema.$ref && !schema.allOf) throw new TypeError("Tool input JSON Schema root must be object");
+	if (typeof schema.$ref === "string") {
+		const ref = schema.$ref;
+		if (!ref.startsWith("#/")) throw new TypeError(`Remote JSON Schema ref "${ref}" is not supported`);
+		if (refs.includes(ref)) throw new TypeError(`JSON Schema ref cycle detected at "${ref}"`);
+		visitSchema(resolveRef(rootDocument, ref), rootDocument, false, limits, stats, [...refs, ref], depth + 1);
+	}
+	if (schema.properties !== void 0) {
+		if (!isRecord(schema.properties)) throw new TypeError("JSON Schema properties must be an object");
+		const entries = Object.entries(schema.properties);
+		if (entries.length > limits.maxProperties) throw new TypeError(`JSON Schema exceeds maxProperties limit of ${limits.maxProperties}`);
+		for (const [, child] of entries) {
+			if (!isRecord(child)) throw new TypeError("JSON Schema property schemas must be objects");
+			visitSchema(child, rootDocument, false, limits, stats, refs, depth + 1);
+		}
+	}
+	for (const key of ["$defs"]) {
+		if (schema[key] === void 0) continue;
+		if (!isRecord(schema[key])) throw new TypeError(`JSON Schema ${key} must be an object`);
+		for (const child of Object.values(schema[key])) {
+			if (!isRecord(child)) throw new TypeError(`JSON Schema ${key} entries must be objects`);
+			visitSchema(child, rootDocument, false, limits, stats, refs, depth + 1);
+		}
+	}
+	if (schema.items !== void 0) {
+		if (!isRecord(schema.items)) throw new TypeError("JSON Schema items must be an object");
+		visitSchema(schema.items, rootDocument, false, limits, stats, refs, depth + 1);
+	}
+	for (const key of [
+		"allOf",
+		"anyOf",
+		"oneOf"
+	]) {
+		if (schema[key] === void 0) continue;
+		if (!Array.isArray(schema[key])) throw new TypeError(`JSON Schema ${key} must be an array`);
+		for (const child of schema[key]) {
+			if (!isRecord(child)) throw new TypeError(`JSON Schema ${key} entries must be objects`);
+			visitSchema(child, rootDocument, false, limits, stats, refs, depth + 1);
+		}
+	}
+	if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
+		if (schema.additionalProperties !== true && !isRecord(schema.additionalProperties)) throw new TypeError("JSON Schema additionalProperties must be boolean or object");
+		if (isRecord(schema.additionalProperties)) visitSchema(schema.additionalProperties, rootDocument, false, limits, stats, refs, depth + 1);
+	}
+}
+function validateValue(schema, rootDocument, value, path, refs) {
+	if (typeof schema.$ref === "string") {
+		if (refs.includes(schema.$ref)) throw new TypeError(`JSON Schema ref cycle detected at "${schema.$ref}"`);
+		return validateValue(resolveRef(rootDocument, schema.$ref), rootDocument, value, path, [...refs, schema.$ref]);
+	}
+	if (Array.isArray(schema.allOf)) for (const child of schema.allOf) validateValue(child, rootDocument, value, path, refs);
+	if (Array.isArray(schema.anyOf)) {
+		if (!schema.anyOf.some((child) => passes(child, rootDocument, value, path, refs))) throw new TypeError(`${path} must match anyOf`);
+	}
+	if (Array.isArray(schema.oneOf)) {
+		if (schema.oneOf.filter((child) => passes(child, rootDocument, value, path, refs)).length !== 1) throw new TypeError(`${path} must match exactly one oneOf schema`);
+	}
+	if ("const" in schema && JSON.stringify(value) !== JSON.stringify(schema.const)) throw new TypeError(`${path} must equal const`);
+	if (Array.isArray(schema.enum) && !schema.enum.some((item) => JSON.stringify(item) === JSON.stringify(value))) throw new TypeError(`${path} must be one of enum`);
+	validateType(schema.type, value, path);
+	if (schema.type === "object" || isRecord(value)) validateObject(schema, rootDocument, value, path, refs);
+	if (schema.type === "array" || Array.isArray(value)) validateArray(schema, rootDocument, value, path, refs);
+	if (typeof value === "string") {
+		if (typeof schema.minLength === "number" && value.length < schema.minLength) throw new TypeError(`${path} is shorter than minLength`);
+		if (typeof schema.maxLength === "number" && value.length > schema.maxLength) throw new TypeError(`${path} is longer than maxLength`);
+	}
+	if (typeof value === "number") {
+		if (typeof schema.minimum === "number" && value < schema.minimum) throw new TypeError(`${path} is below minimum`);
+		if (typeof schema.maximum === "number" && value > schema.maximum) throw new TypeError(`${path} is above maximum`);
+	}
+}
+function validateObject(schema, rootDocument, value, path, refs) {
+	if (!isRecord(value)) return;
+	const required = Array.isArray(schema.required) ? schema.required : [];
+	for (const key of required) if (typeof key === "string" && !(key in value)) throw new TypeError(`${path}.${key} is required`);
+	const properties = isRecord(schema.properties) ? schema.properties : {};
+	for (const [key, child] of Object.entries(properties)) if (key in value && isRecord(child)) validateValue(child, rootDocument, value[key], `${path}.${key}`, refs);
+	if (schema.additionalProperties === false) {
+		for (const key of Object.keys(value)) if (!(key in properties)) throw new TypeError(`${path}.${key} is not allowed`);
+	} else if (isRecord(schema.additionalProperties)) {
+		for (const [key, item] of Object.entries(value)) if (!(key in properties)) validateValue(schema.additionalProperties, rootDocument, item, `${path}.${key}`, refs);
+	}
+}
+function validateArray(schema, rootDocument, value, path, refs) {
+	if (!Array.isArray(value)) return;
+	if (typeof schema.minItems === "number" && value.length < schema.minItems) throw new TypeError(`${path} has fewer than minItems`);
+	if (typeof schema.maxItems === "number" && value.length > schema.maxItems) throw new TypeError(`${path} has more than maxItems`);
+	if (isRecord(schema.items)) value.forEach((item, index) => validateValue(schema.items, rootDocument, item, `${path}[${index}]`, refs));
+}
+function validateType(type, value, path) {
+	if (type === void 0) return;
+	const types = Array.isArray(type) ? type : [type];
+	if (!types.some((item) => {
+		if (item === "array") return Array.isArray(value);
+		if (item === "integer") return Number.isInteger(value);
+		if (item === "number") return typeof value === "number" && Number.isFinite(value);
+		if (item === "object") return isRecord(value);
+		if (item === "null") return value === null;
+		return typeof value === item;
+	})) throw new TypeError(`${path} must be ${types.join(" or ")}`);
+}
+function passes(schema, rootDocument, value, path, refs) {
+	try {
+		validateValue(schema, rootDocument, value, path, refs);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function resolveRef(rootDocument, ref) {
+	const segments = ref.slice(2).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
+	let current = rootDocument;
+	for (const segment of segments) {
+		if (!isRecord(current) || !(segment in current)) throw new TypeError(`JSON Schema ref "${ref}" cannot be resolved`);
+		current = current[segment];
+	}
+	if (!isRecord(current)) throw new TypeError(`JSON Schema ref "${ref}" must resolve to an object`);
+	return current;
+}
+function toJsonValue(value, message) {
+	try {
+		const cloned = JSON.parse(JSON.stringify(value));
+		if (cloned === void 0) throw new TypeError(message);
+		return cloned;
+	} catch {
+		throw new TypeError(message);
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/tools/tool.ts
 function defineTool(tool) {
 	return tool;
 }
@@ -10,4 +230,4 @@ function toToolSpec(tool, inputSchema) {
 	};
 }
 //#endregion
-export { defineTool, toToolSpec };
+export { FEVEX_JSON_SCHEMA_PROFILE_VERSION, IntegrationError, compileFevexJsonSchema, defineConnection, defineTool, toToolSpec, validateFevexJsonSchemaProfile };

package/dist/types-CuoRx12Q.d.mts

@@ -0,0 +1,333 @@
+//#region src/core/types.d.ts
+/** A value that can cross provider and persistence boundaries without conversion. */
+type JsonPrimitive = string | number | boolean | null;
+type JsonObject = {
+  [key: string]: JsonValue;
+};
+type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+type RunId = string;
+declare const SCHEMA_NOT_TRANSPORTABLE = "SCHEMA_NOT_TRANSPORTABLE";
+declare const PROVIDER_SCHEMA_UNSUPPORTED = "PROVIDER_SCHEMA_UNSUPPORTED";
+declare const PROVIDER_REASONING_UNSUPPORTED = "PROVIDER_REASONING_UNSUPPORTED";
+interface ExecutionContext {
+  namespace?: string;
+  actor?: {
+    id: string;
+    type?: string;
+  };
+  attributes?: JsonObject;
+  prompt?: JsonObject;
+}
+type AgentMessageRole = 'system' | 'user' | 'assistant' | 'tool';
+interface AgentMessage {
+  role: AgentMessageRole;
+  content: string;
+  name?: string;
+  toolCallId?: string;
+  toolCalls?: ToolCall[];
+}
+interface ToolSpec {
+  name: string;
+  description?: string;
+  inputSchema?: JsonObject;
+}
+interface ToolCall {
+  id: string;
+  name: string;
+  input: JsonValue;
+}
+interface ToolEventSource {
+  kind: 'connection';
+  provider: string;
+  connectionName: string;
+  remoteToolName: string;
+}
+type AgentEventType = 'run.started' | 'run.recovered' | 'run.paused' | 'run.resumed' | 'model.started' | 'model.output.delta' | 'model.completed' | 'tool.started' | 'tool.completed' | 'tool.failed' | 'tool.retrying' | 'tool.execution_unknown' | 'elicitation.requested' | 'elicitation.resolved' | 'approval.requested' | 'approval.resolved' | 'run.completed' | 'run.failed' | 'run.cancelled' | 'workflow.run.started' | 'workflow.run.recovered' | 'workflow.step.started' | 'workflow.step.completed' | 'workflow.step.failed' | 'workflow.compensation.started' | 'workflow.compensation.completed' | 'workflow.compensation.failed' | 'workflow.wait.started' | 'workflow.wait.completed' | 'workflow.run.paused' | 'workflow.run.resumed' | 'workflow.run.completed' | 'workflow.run.failed' | 'workflow.run.cancelled' | 'team.run.started' | 'team.run.recovered' | 'team.agent.assigned' | 'team.handoff.created' | 'team.task.completed' | 'team.task.failed' | 'team.merge.started' | 'team.merge.completed' | 'team.merge.failed' | 'team.run.paused' | 'team.run.resumed' | 'team.run.completed' | 'team.run.failed' | 'team.run.cancelled';
+interface AgentEventPayloads {
+  'run.started': undefined;
+  'run.recovered': {
+    actorId: string;
+  };
+  'run.paused': {
+    reason: 'elicitation' | 'approval' | 'tool_execution_unknown';
+    toolCallId: string;
+  };
+  'run.resumed': undefined;
+  'model.started': {
+    step: number;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'model.output.delta': {
+    step: number;
+    delta: string;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'model.completed': {
+    step: number;
+    usage?: JsonObject;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.started': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    attempt?: number;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.completed': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    attempt?: number;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.failed': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.retrying': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    attempt: number;
+    delayMs: number;
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'tool.execution_unknown': {
+    step: number;
+    toolCallId: string;
+    toolName: string;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'elicitation.requested': {
+    request: {
+      id: string;
+      toolCallId: string;
+      prompt: string;
+      responseSchema: JsonObject;
+      requestedAt: string;
+      expiresAt?: string;
+    };
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'elicitation.resolved': {
+    requestId: string;
+    toolCallId: string;
+    actorId: string;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'approval.requested': {
+    approvalId: string;
+    toolCallId: string;
+    toolName: string;
+    toolLabel?: string;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'approval.resolved': {
+    approvalId: string;
+    toolCallId: string;
+    decision: 'approve' | 'reject';
+    actorId: string;
+    toolLabel?: string;
+    source?: ToolEventSource;
+    workflowStepId?: string;
+    workflowAgentName?: string;
+    teamDelegationId?: string;
+    teamAgentName?: string;
+  };
+  'run.completed': {
+    output: JsonValue;
+    usage?: JsonObject;
+  };
+  'run.failed': {
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+  };
+  'run.cancelled': {
+    reason: 'aborted' | 'timeout' | 'approval_rejected';
+  };
+  'workflow.run.started': undefined;
+  'workflow.run.recovered': {
+    actorId: string;
+  };
+  'workflow.step.started': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+    agentName?: string;
+  };
+  'workflow.step.completed': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+  };
+  'workflow.step.failed': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+    error: string;
+  };
+  'workflow.compensation.started': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+  };
+  'workflow.compensation.completed': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+  };
+  'workflow.compensation.failed': {
+    stepId: string;
+    kind: 'agent' | 'parallel';
+    error: string;
+  };
+  'workflow.wait.started': {
+    stepId: string;
+    kind: 'timer' | 'event';
+    resumeAt?: string;
+    eventName?: string;
+  };
+  'workflow.wait.completed': {
+    stepId: string;
+    kind: 'timer' | 'event';
+    payload?: JsonValue;
+    actorId?: string;
+    receivedAt?: string;
+  };
+  'workflow.run.paused': {
+    stepId: string;
+    reason: 'child' | 'timer' | 'event';
+    childRunId?: string;
+  };
+  'workflow.run.resumed': undefined;
+  'workflow.run.completed': {
+    output: JsonValue;
+    usage?: JsonObject;
+  };
+  'workflow.run.failed': {
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+  };
+  'workflow.run.cancelled': {
+    reason: 'aborted' | 'timeout' | 'approval_rejected';
+  };
+  'team.run.started': undefined;
+  'team.run.recovered': {
+    actorId: string;
+  };
+  'team.agent.assigned': {
+    delegationId: string;
+    agentName: string;
+    action: 'delegate' | 'handoff';
+    expectedOutput?: string;
+    constraints?: string[];
+  };
+  'team.handoff.created': {
+    delegationId: string;
+    from: string;
+    to: string;
+    reason: string;
+  };
+  'team.task.completed': {
+    delegationId: string;
+    agentName: string;
+    usage?: JsonObject;
+  };
+  'team.task.failed': {
+    delegationId: string;
+    agentName?: string;
+    error: string;
+  };
+  'team.merge.started': {
+    stepId: string;
+    width: number;
+  };
+  'team.merge.completed': {
+    stepId: string;
+  };
+  'team.merge.failed': {
+    stepId: string;
+    error: string;
+  };
+  'team.run.paused': {
+    delegationId: string;
+    reason: 'child' | 'timer' | 'event';
+    childRunId?: string;
+  };
+  'team.run.resumed': undefined;
+  'team.run.completed': {
+    output: JsonValue;
+    usage?: JsonObject;
+  };
+  'team.run.failed': {
+    error: string;
+    errorCode?: string;
+    retryable?: boolean;
+    source?: ToolEventSource;
+  };
+  'team.run.cancelled': {
+    reason: 'aborted' | 'timeout' | 'approval_rejected';
+  };
+}
+interface AgentEventBase {
+  id: string;
+  sequence: number;
+  runId: RunId;
+  timestamp: string;
+}
+type AgentEvent<TType extends AgentEventType = AgentEventType> = { [TCurrent in TType]: AgentEventBase & {
+  type: TCurrent;
+} & (AgentEventPayloads[TCurrent] extends undefined ? {
+  payload?: never;
+} : {
+  payload: AgentEventPayloads[TCurrent];
+}); }[TType];
+//#endregion
+export { AgentMessageRole as a, JsonPrimitive as c, PROVIDER_SCHEMA_UNSUPPORTED as d, RunId as f, ToolSpec as g, ToolEventSource as h, AgentMessage as i, JsonValue as l, ToolCall as m, AgentEventPayloads as n, ExecutionContext as o, SCHEMA_NOT_TRANSPORTABLE as p, AgentEventType as r, JsonObject as s, AgentEvent as t, PROVIDER_REASONING_UNSUPPORTED as u };

package/dist/workflows/index.d.mts

@@ -0,0 +1,2 @@
+import { a as WorkflowStep, c as defineWorkflow, i as WorkflowEventResult, n as WorkflowDefinition, o as WorkflowStepContext, r as WorkflowEventDefinition, s as WorkflowStepOptions, t as WorkflowAgentResult } from "../index-DviHtsLo.mjs";
+export { WorkflowAgentResult, WorkflowDefinition, WorkflowEventDefinition, WorkflowEventResult, WorkflowStep, WorkflowStepContext, WorkflowStepOptions, defineWorkflow };

package/dist/workflows/index.mjs

@@ -0,0 +1,6 @@
+//#region src/workflows/workflow.ts
+function defineWorkflow(workflow) {
+	return workflow;
+}
+//#endregion
+export { defineWorkflow };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fevex/core",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.2",
   "description": "Agent Engineering Framework for code-first, provider-neutral AI agents.",
   "type": "module",
   "license": "Apache-2.0",
@@ -31,6 +31,18 @@
       "types": "./dist/agents/index.d.mts",
       "import": "./dist/agents/index.mjs"
     },
+    "./channels": {
+      "types": "./dist/channels/index.d.mts",
+      "import": "./dist/channels/index.mjs"
+    },
+    "./http": {
+      "types": "./dist/http/index.d.mts",
+      "import": "./dist/http/index.mjs"
+    },
+    "./knowledge": {
+      "types": "./dist/knowledge/index.d.mts",
+      "import": "./dist/knowledge/index.mjs"
+    },
     "./models": {
       "types": "./dist/models/index.d.mts",
       "import": "./dist/models/index.mjs"
@@ -39,19 +51,43 @@
       "types": "./dist/tools/index.d.mts",
       "import": "./dist/tools/index.mjs"
     },
+    "./workflows": {
+      "types": "./dist/workflows/index.d.mts",
+      "import": "./dist/workflows/index.mjs"
+    },
+    "./teams": {
+      "types": "./dist/teams/index.d.mts",
+      "import": "./dist/teams/index.mjs"
+    },
     "./runtime": {
       "types": "./dist/runtime/index.d.mts",
       "import": "./dist/runtime/index.mjs"
     },
+    "./sandbox": {
+      "types": "./dist/sandbox/index.d.mts",
+      "import": "./dist/sandbox/index.mjs"
+    },
+    "./policies": {
+      "types": "./dist/policies/index.d.mts",
+      "import": "./dist/policies/index.mjs"
+    },
+    "./observability": {
+      "types": "./dist/observability/index.d.mts",
+      "import": "./dist/observability/index.mjs"
+    },
+    "./evals": {
+      "types": "./dist/evals/index.d.mts",
+      "import": "./dist/evals/index.mjs"
+    },
     "./testing": {
       "types": "./dist/testing/index.d.mts",
       "import": "./dist/testing/index.mjs"
     }
   },
   "scripts": {
-    "build": "tsdown src/index.ts src/agents/index.ts src/models/index.ts src/tools/index.ts src/runtime/index.ts src/testing/index.ts --format esm --dts",
+    "build": "tsdown src/index.ts src/agents/index.ts src/channels/index.ts src/http/index.ts src/knowledge/index.ts src/models/index.ts src/tools/index.ts src/workflows/index.ts src/teams/index.ts src/runtime/index.ts src/sandbox/index.ts src/policies/index.ts src/observability/index.ts src/evals/index.ts src/testing/index.ts --format esm --dts --clean",
     "prepack": "bun run build",
-    "test": "bun test src/index.test.ts src/testing/index.test.ts",
+    "test": "bun test --cwd src",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "publishConfig": {

package/dist/index-D_RBJmVt.d.mts

@@ -1,44 +0,0 @@
-//#region src/core/index.d.ts
-type JsonPrimitive = string | number | boolean | null;
-type JsonObject = {
-  [key: string]: JsonValue;
-};
-type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
-type RunId = string;
-declare const SCHEMA_NOT_TRANSPORTABLE = "SCHEMA_NOT_TRANSPORTABLE";
-interface ExecutionContext {
-  namespace?: string;
-  actor?: {
-    id: string;
-    type?: string;
-  };
-  attributes?: JsonObject;
-  prompt?: JsonObject;
-}
-type AgentMessageRole = 'system' | 'user' | 'assistant' | 'tool';
-interface AgentMessage {
-  role: AgentMessageRole;
-  content: string;
-  name?: string;
-  toolCallId?: string;
-  toolCalls?: ToolCall[];
-}
-interface ToolSpec {
-  name: string;
-  description?: string;
-  inputSchema?: JsonObject;
-}
-interface ToolCall {
-  id: string;
-  name: string;
-  input: JsonValue;
-}
-type AgentEventType = 'run.started' | 'model.completed' | 'tool.completed' | 'tool.failed' | 'run.completed' | 'run.failed';
-interface AgentEvent<TPayload extends JsonValue = JsonObject> {
-  type: AgentEventType;
-  runId: RunId;
-  timestamp: string;
-  payload?: TPayload;
-}
-//#endregion
-export { ExecutionContext as a, JsonValue as c, ToolCall as d, ToolSpec as f, AgentMessageRole as i, RunId as l, AgentEventType as n, JsonObject as o, AgentMessage as r, JsonPrimitive as s, AgentEvent as t, SCHEMA_NOT_TRANSPORTABLE as u };