@otakumesi/heph 0.0.1

package/dist/index-CdsI9z7r.d.mts

@@ -0,0 +1,1075 @@
+import { z } from "zod";
+
+//#region ../core/src/types.d.ts
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+type JsonObject = {
+  [key: string]: JsonValue;
+};
+type JsonSchema = Record<string, unknown>;
+type AgentSessionId = string;
+type RunId = string;
+type MessageId = string;
+type RunEventId = string;
+type MemoryId = string;
+type InboxEventId = string;
+type DeferredToolOperationId = string;
+type AgentSpecId = string;
+type McpBindingId = string;
+type SkillBindingId = string;
+type ApprovalRequestId = string;
+interface AuthContext {
+  subject: string;
+  userId?: string | undefined;
+  tenantId?: string | undefined;
+  roles?: string[] | undefined;
+  scopes?: string[] | undefined;
+  actorType?: "user" | "service" | "anonymous" | undefined;
+  claims?: Record<string, unknown> | undefined;
+}
+interface AuthAdapter {
+  authenticate(request: Request): Promise<AuthContext | null>;
+}
+interface SourceRef {
+  type: "message" | "run_event" | "artifact" | "manual" | "memory" | "inbox_event" | "mcp_binding" | "skill_binding" | "approval_request" | "deferred_tool_operation";
+  id: string;
+}
+interface AgentSession {
+  id: AgentSessionId;
+  agentSpecId: AgentSpecId;
+  agentSpecVersion: string | null;
+  state: Record<string, unknown>;
+  activeRunId: RunId | null;
+  auth: AuthContext | null;
+  metadata: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}
+type RunStatus = "queued" | "running" | "paused" | "completed" | "failed" | "cancelled";
+type RunInput = {
+  type: "user.message" | "steering.message" | "follow_up.message";
+  text: string;
+  messageIds?: MessageId[];
+  payload?: unknown;
+} | {
+  type: "approval.granted" | "approval.rejected" | "run.cancel_requested" | "webhook.received" | "system.event";
+  payload?: unknown;
+  messageIds?: MessageId[];
+};
+interface RunError {
+  code?: string;
+  message: string;
+  details?: Record<string, unknown>;
+}
+interface Run {
+  id: RunId;
+  agentId: AgentSessionId;
+  agentSpecId: AgentSpecId;
+  agentSpecVersion: string | null;
+  status: RunStatus;
+  input: RunInput;
+  auth: AuthContext | null;
+  contextManifest: ContextManifest | null;
+  skillManifest: SkillManifest | null;
+  toolManifest: ToolManifest | null;
+  error: RunError | null;
+  metadata: Record<string, unknown>;
+  queuedAt: Date;
+  startedAt: Date | null;
+  completedAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+type MessageRole = "system" | "developer" | "user" | "assistant" | "tool";
+interface Message {
+  id: MessageId;
+  agentId: AgentSessionId;
+  role: MessageRole;
+  content: string;
+  sourceRunId: RunId | null;
+  auth: AuthContext | null;
+  metadata: Record<string, unknown>;
+  createdAt: Date;
+}
+type InboxEventStatus = "pending" | "processing" | "processed" | "failed";
+interface InboxEvent {
+  id: InboxEventId;
+  agentId: AgentSessionId;
+  type: RunInput["type"];
+  input: RunInput;
+  status: InboxEventStatus;
+  runId: RunId | null;
+  auth: AuthContext | null;
+  metadata: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+  claimedAt: Date | null;
+  processedAt: Date | null;
+  failedAt: Date | null;
+  error: RunError | null;
+}
+type RunEventType = "run.cancel_requested" | "run.queued" | "run.started" | "run.steering_received" | "run.paused" | "run.completed" | "run.failed" | "run.cancelled" | "turn.started" | "turn.completed" | "message.started" | "message.delta" | "message.completed" | "tool.started" | "tool.updated" | "tool.deferred" | "tool.completed" | "tool.failed" | "deferred_tool.completed" | "deferred_tool.failed" | "skill_manifest.created" | "tool_manifest.created" | "approval.requested" | "approval.granted" | "approval.rejected" | "context.rendered";
+interface RunEvent {
+  id: RunEventId;
+  runId: RunId;
+  seq: number;
+  type: RunEventType;
+  payload: Record<string, unknown>;
+  sourceRefs: SourceRef[];
+  createdAt: Date;
+}
+interface MemoryScope {
+  type: "user" | "project" | "team" | "agent" | "session";
+  id: string;
+}
+interface MemoryItem {
+  id: MemoryId;
+  scope: MemoryScope;
+  kind: "fact" | "preference" | "decision" | "summary" | "entity" | "lesson";
+  content: string;
+  sourceRefs: SourceRef[];
+  importance: number | null;
+  confidence: number | null;
+  embeddingRef: string | null;
+  expiresAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+type ContextBlockType = "policy" | "agent_identity" | "state" | "memory" | "message_summary" | "message_history" | "context_provider" | "skill" | "tool_manifest" | "artifact" | "team" | "input";
+interface ContextBlock {
+  key: string;
+  type: ContextBlockType;
+  content: string;
+  priority?: number;
+  sourceRefs?: SourceRef[];
+  metadata?: Record<string, unknown>;
+}
+interface ContextSlot {
+  required?: boolean;
+  maxTokens?: number;
+}
+interface ContextTemplateMessage {
+  role: Extract<MessageRole, "system" | "developer" | "user" | "assistant">;
+  content: string;
+}
+interface ContextTemplate$1 {
+  id: string;
+  version: string;
+  slots: Record<string, ContextSlot>;
+  messages: ContextTemplateMessage[];
+}
+interface ContextManifestBlock {
+  key: string;
+  type: ContextBlockType;
+  tokens: number;
+  sourceRefs: SourceRef[];
+  truncated: boolean;
+}
+interface ContextManifest {
+  runId: RunId;
+  contextTemplateId: string;
+  contextTemplateVersion: string;
+  blocks: ContextManifestBlock[];
+  totalTokens: number;
+  createdAt: Date;
+}
+interface RenderedContext {
+  messages: ContextTemplateMessage[];
+  manifest: ContextManifest;
+}
+interface ToolExecutionContext<TApp = unknown> {
+  auth: AuthContext | null;
+  agent: AgentSession;
+  run: Run;
+  app: TApp;
+  signal: AbortSignal;
+}
+type ToolConcurrencyKeyFn<TInput> = (args: {
+  input: TInput;
+  auth: AuthContext | null;
+  agent: AgentSession;
+}) => string;
+interface Tool$1<TInput = unknown, TResult = unknown, TApp = unknown> {
+  id: string;
+  description: string;
+  inputSchema: z.ZodType;
+  jsonSchema: JsonSchema;
+  sideEffect: boolean;
+  requiresApproval: boolean;
+  concurrencyKey?: ToolConcurrencyKeyFn<TInput>;
+  execute(input: TInput, ctx: ToolExecutionContext<TApp>): Promise<TResult> | TResult;
+}
+type ToolManifestSource = "local" | "mcp";
+interface ToolManifest {
+  runId: RunId;
+  tools: ToolManifestTool[];
+  createdAt: Date;
+}
+type ToolManifestTool = LocalToolManifestTool | McpToolManifestTool;
+interface ToolManifestToolBase {
+  id: string;
+  displayName: string;
+  source: ToolManifestSource;
+  description: string;
+  inputSchema: JsonSchema;
+  sideEffect: boolean | null;
+  requiresApproval: boolean;
+  metadata: Record<string, unknown>;
+}
+interface LocalToolManifestTool extends ToolManifestToolBase {
+  source: "local";
+  localToolId: string;
+}
+interface McpToolManifestTool extends ToolManifestToolBase {
+  source: "mcp";
+  bindingId: McpBindingId;
+  capabilityId: string;
+  remoteToolName: string;
+  transport: "streamable_http";
+}
+interface ToolDefinition<TSchema extends z.ZodType, TResult = unknown, TApp = unknown> {
+  id: string;
+  description: string;
+  inputSchema: TSchema;
+  sideEffect?: boolean;
+  requiresApproval?: boolean;
+  concurrencyKey?: ToolConcurrencyKeyFn<z.infer<TSchema>>;
+  execute(input: z.infer<TSchema>, ctx: ToolExecutionContext<TApp>): Promise<TResult> | TResult;
+}
+type SkillBindingSource = {
+  type: "local";
+  pathOrRef: string;
+} | {
+  type: "host-resolved";
+  pathOrRef?: string | undefined;
+};
+type SkillBindingStatus = "active" | "removed";
+type SkillAllowReferences = string[] | "all";
+interface SkillResourceRef {
+  id: string;
+  pathOrRef: string;
+  contentType: string | null;
+  metadata: Record<string, unknown>;
+}
+interface SkillPackage {
+  id: string;
+  name: string;
+  description: string;
+  version: string | null;
+  instructions: string;
+  source: SkillBindingSource;
+  references: SkillResourceRef[];
+  assets: SkillResourceRef[];
+  templates: SkillResourceRef[];
+  metadata: Record<string, unknown>;
+  loadedAt: Date;
+}
+interface SkillCatalog {
+  getSkill(id: string): Promise<SkillPackage | null>;
+  listSkills?(): Promise<SkillPackage[]>;
+}
+interface SkillManifest {
+  runId: RunId;
+  skills: SkillManifestEntry[];
+  createdAt: Date;
+}
+interface SkillManifestEntry {
+  bindingId: SkillBindingId;
+  skillId: string;
+  name: string;
+  version: string | null;
+  description: string;
+  instructions: string;
+  descriptionHash: string;
+  instructionHash: string;
+  source: SkillBindingSource;
+  availableReferences: SkillResourceRef[];
+  availableAssets: SkillResourceRef[];
+  availableTemplates: SkillResourceRef[];
+  metadata: Record<string, unknown>;
+}
+interface ContextProviderContext<TApp = unknown> {
+  auth: AuthContext | null;
+  agent: AgentSession;
+  run: Run;
+  spec: AgentSpec$1<TApp>;
+  input: RunInput;
+  stores: HephStores;
+  app: TApp;
+}
+interface ContextProvider$1<TApp = unknown> {
+  id: string;
+  load(ctx: ContextProviderContext<TApp>): Promise<ContextBlock | ContextBlock[] | null | undefined>;
+}
+interface ContextProviderDefinition<TApp = unknown> {
+  id: string;
+  load(ctx: ContextProviderContext<TApp>): Promise<ContextBlock | ContextBlock[] | null | undefined>;
+}
+interface AgentSpec$1<TApp = unknown> {
+  id: AgentSpecId;
+  version: string | null;
+  instructions: string;
+  model: string | null;
+  tools: Tool$1<any, any, TApp>[];
+  mcp: McpAgentPolicy | null;
+  skills: SkillAgentPolicy | null;
+  contextProviders: ContextProvider$1<TApp>[];
+  contextTemplate: ContextTemplate$1 | null;
+  metadata: Record<string, unknown>;
+}
+interface AgentDefinition<TApp = unknown> {
+  id: AgentSpecId;
+  version?: string;
+  instructions: string;
+  model?: string;
+  tools?: Tool$1<any, any, TApp>[];
+  mcp?: McpAgentPolicy | string[] | null;
+  allowAllMcpTools?: boolean;
+  skills?: SkillAgentPolicy | string[] | "all" | null;
+  contextProviders?: ContextProvider$1<TApp>[];
+  context?: ContextProvider$1<TApp>[];
+  contextTemplate?: ContextTemplate$1;
+  metadata?: Record<string, unknown>;
+}
+interface McpAgentPolicy {
+  allowCapabilities: string[];
+  allowAllTools?: boolean;
+}
+interface SkillAgentPolicy {
+  allow: string[] | "all";
+}
+type McpAllowTools = string[] | "all";
+type McpBindingStatus = "active" | "removed";
+interface McpBinding {
+  id: McpBindingId;
+  agentId: AgentSessionId;
+  capabilityId: string;
+  accountRef: string | null;
+  allowTools: McpAllowTools;
+  status: McpBindingStatus;
+  metadata: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+  removedAt: Date | null;
+}
+interface CreateMcpBindingStoreInput {
+  id?: McpBindingId;
+  agentId: AgentSessionId;
+  capabilityId: string;
+  accountRef?: string | null | undefined;
+  allowTools: McpAllowTools;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface SkillBinding {
+  id: SkillBindingId;
+  agentId: AgentSessionId;
+  skillId: string;
+  name: string;
+  version: string | null;
+  source: SkillBindingSource;
+  allowReferences: SkillAllowReferences;
+  status: SkillBindingStatus;
+  metadata: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+  removedAt: Date | null;
+}
+interface CreateSkillBindingStoreInput {
+  id?: SkillBindingId;
+  agentId: AgentSessionId;
+  skillId: string;
+  name: string;
+  version?: string | null | undefined;
+  source: SkillBindingSource;
+  allowReferences?: SkillAllowReferences | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+type ApprovalRequestStatus = "pending" | "granted" | "rejected";
+interface ApprovalRequest {
+  id: ApprovalRequestId;
+  agentId: AgentSessionId;
+  runId: RunId;
+  toolId: string;
+  input: unknown;
+  status: ApprovalRequestStatus;
+  requestedBy: AuthContext | null;
+  decidedBy: AuthContext | null;
+  metadata: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+  decidedAt: Date | null;
+}
+type DeferredToolOperationStatus = "pending" | "completed" | "failed" | "cancelled";
+type DeferredToolResumePolicy = "auto" | "manual";
+interface DeferredToolOperation {
+  id: DeferredToolOperationId;
+  agentId: AgentSessionId;
+  runId: RunId;
+  toolId: string;
+  toolCallId: string | null;
+  status: DeferredToolOperationStatus;
+  resumePolicy: DeferredToolResumePolicy;
+  auth: AuthContext | null;
+  result: unknown;
+  error: RunError | null;
+  metadata: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+  completedAt: Date | null;
+}
+interface CreateDeferredToolOperationStoreInput {
+  id?: DeferredToolOperationId;
+  agentId: AgentSessionId;
+  runId: RunId;
+  toolId: string;
+  toolCallId?: string | null | undefined;
+  resumePolicy?: DeferredToolResumePolicy | undefined;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface CompleteDeferredToolOperationStoreInput {
+  id: DeferredToolOperationId;
+  status: Extract<DeferredToolOperationStatus, "completed" | "failed" | "cancelled">;
+  result?: unknown;
+  error?: RunError | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface CreateApprovalRequestStoreInput {
+  id?: ApprovalRequestId;
+  agentId: AgentSessionId;
+  runId: RunId;
+  toolId: string;
+  input: unknown;
+  requestedBy?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface DecideApprovalRequestStoreInput {
+  id: ApprovalRequestId;
+  decision: Extract<ApprovalRequestStatus, "granted" | "rejected">;
+  decidedBy?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface McpCatalogTool {
+  name: string;
+  description?: string | undefined;
+  inputSchema?: JsonSchema | undefined;
+  sideEffect?: boolean | null | undefined;
+  requiresApproval?: boolean | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface McpResolvedCredentials {
+  headers?: Record<string, string> | undefined;
+}
+interface McpBindingResolverContext<TApp = unknown> {
+  auth: AuthContext | null;
+  agent: AgentSession;
+  binding: McpBinding;
+  app: TApp;
+}
+interface McpCredentialResolverContext<TApp = unknown> extends McpBindingResolverContext<TApp> {
+  run?: Run | undefined;
+}
+interface ResolvedMcpBinding<TApp = unknown> {
+  transport: "streamable_http";
+  endpoint: string;
+  tools: McpCatalogTool[];
+  resolveCredentials?: ((ctx: McpCredentialResolverContext<TApp>) => McpResolvedCredentials | Promise<McpResolvedCredentials>) | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface McpBindingResolver<TApp = unknown> {
+  resolve(ctx: McpBindingResolverContext<TApp>): ResolvedMcpBinding<TApp> | Promise<ResolvedMcpBinding<TApp>>;
+}
+interface McpToolCallContext<TApp = unknown> {
+  auth: AuthContext | null;
+  agent: AgentSession;
+  run: Run;
+  binding: McpBinding;
+  manifestTool: McpToolManifestTool;
+  resolved: ResolvedMcpBinding<TApp>;
+  input: unknown;
+  app: TApp;
+  signal?: AbortSignal | undefined;
+}
+interface McpToolExecutor<TApp = unknown> {
+  callTool(ctx: McpToolCallContext<TApp>): Promise<unknown>;
+}
+interface CreateAgentSessionStoreInput {
+  id?: AgentSessionId;
+  agentSpecId: AgentSpecId;
+  agentSpecVersion?: string | null | undefined;
+  state?: Record<string, unknown> | undefined;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface CreateRunStoreInput {
+  id?: RunId;
+  agentId: AgentSessionId;
+  agentSpecId: AgentSpecId;
+  agentSpecVersion?: string | null | undefined;
+  status: RunStatus;
+  input: RunInput;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface AppendMessageInput {
+  id?: MessageId;
+  agentId: AgentSessionId;
+  role: MessageRole;
+  content: string;
+  sourceRunId?: RunId | null | undefined;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface AppendInboxEventInput {
+  id?: InboxEventId;
+  agentId: AgentSessionId;
+  input: RunInput;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface AppendRunEventInput {
+  id?: RunEventId;
+  runId: RunId;
+  type: RunEventType;
+  payload?: Record<string, unknown> | undefined;
+  sourceRefs?: SourceRef[] | undefined;
+}
+interface PutMemoryInput {
+  id?: MemoryId;
+  scope: MemoryScope;
+  kind: MemoryItem["kind"];
+  content: string;
+  sourceRefs: SourceRef[];
+  importance?: number | null;
+  confidence?: number | null;
+  embeddingRef?: string | null;
+  expiresAt?: Date | null;
+}
+interface SearchMemoryInput {
+  query?: string;
+  scopes?: MemoryScope[];
+  topK?: number;
+}
+interface StateStore {
+  createAgentSession(input: CreateAgentSessionStoreInput): Promise<AgentSession>;
+  getAgentSession(id: AgentSessionId): Promise<AgentSession | null>;
+  updateAgentSession(id: AgentSessionId, patch: Partial<Omit<AgentSession, "id" | "createdAt">>): Promise<AgentSession>;
+  createRun(input: CreateRunStoreInput): Promise<Run>;
+  getRun(id: RunId): Promise<Run | null>;
+  updateRun(id: RunId, patch: Partial<Omit<Run, "id" | "createdAt">>): Promise<Run>;
+  listRunsByAgent(agentId: AgentSessionId): Promise<Run[]>;
+}
+interface MessageStore {
+  appendMessage(input: AppendMessageInput): Promise<Message>;
+  listMessages(agentId: AgentSessionId, options?: {
+    limit?: number;
+  }): Promise<Message[]>;
+}
+interface InboxStore {
+  appendInboxEvent(input: AppendInboxEventInput): Promise<InboxEvent>;
+  getInboxEvent(id: InboxEventId): Promise<InboxEvent | null>;
+  listInboxEvents(agentId: AgentSessionId, options?: {
+    status?: InboxEventStatus;
+    types?: RunInput["type"][];
+    limit?: number;
+  }): Promise<InboxEvent[]>;
+  claimPendingInboxEvents(agentId: AgentSessionId, options?: {
+    types?: RunInput["type"][];
+    limit?: number;
+  }): Promise<InboxEvent[]>;
+  markInboxEventsProcessed(ids: InboxEventId[], runId: RunId): Promise<InboxEvent[]>;
+  markInboxEventsFailed(ids: InboxEventId[], error: RunError): Promise<InboxEvent[]>;
+}
+interface EventLog {
+  appendRunEvent(input: AppendRunEventInput): Promise<RunEvent>;
+  listRunEvents(runId: RunId, options?: {
+    after?: number;
+    limit?: number;
+  }): Promise<RunEvent[]>;
+}
+interface MemoryStore {
+  putMemory(input: PutMemoryInput): Promise<MemoryItem>;
+  searchMemory(input: SearchMemoryInput): Promise<MemoryItem[]>;
+}
+interface McpBindingStore {
+  createMcpBinding(input: CreateMcpBindingStoreInput): Promise<McpBinding>;
+  getMcpBinding(id: McpBindingId): Promise<McpBinding | null>;
+  listMcpBindings(agentId: AgentSessionId, options?: {
+    status?: McpBindingStatus | "all" | undefined;
+  }): Promise<McpBinding[]>;
+  removeMcpBinding(id: McpBindingId): Promise<McpBinding>;
+}
+interface SkillBindingStore {
+  createSkillBinding(input: CreateSkillBindingStoreInput): Promise<SkillBinding>;
+  getSkillBinding(id: SkillBindingId): Promise<SkillBinding | null>;
+  listSkillBindings(agentId: AgentSessionId, options?: {
+    status?: SkillBindingStatus | "all" | undefined;
+  }): Promise<SkillBinding[]>;
+  removeSkillBinding(id: SkillBindingId): Promise<SkillBinding>;
+}
+interface ApprovalStore {
+  createApprovalRequest(input: CreateApprovalRequestStoreInput): Promise<ApprovalRequest>;
+  getApprovalRequest(id: ApprovalRequestId): Promise<ApprovalRequest | null>;
+  listApprovalRequests(runId: RunId, options?: {
+    status?: ApprovalRequestStatus | "all" | undefined;
+  }): Promise<ApprovalRequest[]>;
+  decideApprovalRequest(input: DecideApprovalRequestStoreInput): Promise<ApprovalRequest>;
+}
+interface DeferredToolOperationStore {
+  createDeferredToolOperation(input: CreateDeferredToolOperationStoreInput): Promise<DeferredToolOperation>;
+  getDeferredToolOperation(id: DeferredToolOperationId): Promise<DeferredToolOperation | null>;
+  completeDeferredToolOperation(input: CompleteDeferredToolOperationStoreInput): Promise<DeferredToolOperation>;
+}
+interface HephStores {
+  state: StateStore;
+  messages: MessageStore;
+  inbox: InboxStore;
+  events: EventLog;
+  memory: MemoryStore;
+  mcpBindings: McpBindingStore;
+  skillBindings: SkillBindingStore;
+  approvals: ApprovalStore;
+  deferredToolOperations: DeferredToolOperationStore;
+}
+//#endregion
+//#region ../core/src/context.d.ts
+interface ContextRendererOptions {
+  template: ContextTemplate$1;
+  blocks: ContextBlock[];
+  runId: RunId;
+  input: string;
+  runtime?: Record<string, string>;
+}
+declare class ContextRenderer {
+  render(options: ContextRendererOptions): RenderedContext;
+}
+declare const defaultContextTemplate: ContextTemplate$1;
+declare function estimateTokens(content: string): number;
+declare function messagesToText(messages: ContextTemplateMessage[]): string;
+//#endregion
+//#region ../core/src/definitions.d.ts
+declare function defineAgent<TApp = unknown>(definition: AgentDefinition<TApp>): AgentSpec$1<TApp>;
+declare function defineContextProvider<TApp = unknown>(definition: ContextProviderDefinition<TApp>): ContextProvider$1<TApp>;
+declare function defineContextTemplate(template: ContextTemplate$1): ContextTemplate$1;
+declare function defineTool<TSchema extends z.ZodType, TResult = unknown, TApp = unknown>(definition: ToolDefinition<TSchema, TResult, TApp>): Tool$1<z.infer<TSchema>, TResult, TApp>;
+declare const AgentSpec: {
+  define: typeof defineAgent;
+};
+declare const ContextProvider: {
+  define: typeof defineContextProvider;
+};
+declare const ContextTemplate: {
+  define: typeof defineContextTemplate;
+};
+declare const Tool: {
+  define: typeof defineTool;
+};
+//#endregion
+//#region ../core/src/errors.d.ts
+type HephErrorCode = "HEPH1001" | "HEPH2001" | "HEPH3001" | "HEPH3002" | "HEPH3003" | "HEPH3004" | "HEPH3005" | "HEPH4001" | "HEPH4002" | "HEPH4003" | "HEPH4004" | "HEPH4005" | "HEPH4006" | "HEPH5001" | "HEPH6001" | "HEPH6002" | "HEPH6003" | "HEPH6004" | "HEPH6005" | "HEPH7001" | "HEPH7002" | "HEPH8001" | "HEPH8002" | "HEPH8003" | "HEPH8004" | "HEPH9001" | "HEPH9002" | "HEPH9003";
+interface HephErrorOptions {
+  code: HephErrorCode;
+  title: string;
+  message?: string;
+  details?: Record<string, unknown>;
+  cause?: unknown;
+  status?: number;
+}
+declare class HephError extends Error {
+  readonly code: HephErrorCode;
+  readonly title: string;
+  readonly details?: Record<string, unknown>;
+  readonly status?: number;
+  constructor(options: HephErrorOptions);
+}
+declare function isHephError(error: unknown): error is HephError;
+declare function toErrorDetails(error: unknown): Record<string, unknown>;
+//#endregion
+//#region ../core/src/queue.d.ts
+type HephJob = {
+  type: "schedule_agent";
+  agentId: string;
+} | {
+  type: "execute_run";
+  agentId: string;
+  runId: string;
+} | {
+  type: "resume_run";
+  agentId: string;
+  runId: string;
+} | {
+  type: "cancel_run";
+  agentId: string;
+  runId: string;
+} | {
+  type: "ingest_memory";
+  agentId: string;
+  runId?: string;
+};
+interface EnqueueOptions {
+  delayMs?: number;
+  idempotencyKey?: string;
+}
+interface QueueAdapter {
+  enqueue(job: HephJob, options?: EnqueueOptions): Promise<void>;
+  startConsumer?(handler: (job: HephJob) => Promise<void>): Promise<void>;
+  handleBatch?(rawEvent: unknown, handler: (job: HephJob) => Promise<void>): Promise<void>;
+  onIdle?(): Promise<void>;
+}
+interface InProcessQueueOptions {
+  concurrency?: number;
+  onError?: (error: unknown, job: HephJob) => void;
+}
+declare class InProcessQueue implements QueueAdapter {
+  private readonly concurrency;
+  private readonly onError;
+  private readonly jobs;
+  private readonly activeAgents;
+  private readonly idleResolvers;
+  private activeCount;
+  private scheduled;
+  private handler;
+  constructor(options?: InProcessQueueOptions);
+  startConsumer(handler: (job: HephJob) => Promise<void>): Promise<void>;
+  enqueue(job: HephJob): Promise<void>;
+  onIdle(): Promise<void>;
+  private schedule;
+  private pump;
+  private isIdle;
+  private resolveIdleIfNeeded;
+}
+//#endregion
+//#region ../core/src/runtime.d.ts
+interface AgentSpecResolverContext {
+  auth: AuthContext | null;
+}
+interface AgentSpecResolver<TApp = unknown> {
+  resolve(id: AgentSpecId, ctx: AgentSpecResolverContext): Promise<AgentSpec$1<TApp> | null>;
+}
+type AgentSpecRegistration<TApp = unknown> = AgentSpec$1<TApp>[] | Record<string, AgentSpec$1<TApp>> | AgentSpecResolver<TApp>;
+interface CreateHephOptions<TApp = unknown> {
+  agents: AgentSpecRegistration<TApp>;
+  stores?: HephStores;
+  queue?: QueueAdapter;
+  executor?: RunExecutor<TApp>;
+  app?: TApp;
+  inbox?: {
+    maxEventsPerRun?: number | null | undefined;
+    textSeparator?: string | undefined;
+  };
+  execution?: {
+    mode?: "single-process" | "platform-queue" | "split-worker";
+    concurrency?: number;
+    autoStartConsumer?: boolean;
+  };
+  runtimePolicy?: string;
+  toolPolicy?: string;
+  mcp?: {
+    resolver?: McpBindingResolver<TApp> | undefined;
+    toolExecutor?: McpToolExecutor<TApp> | undefined;
+  };
+  skills?: {
+    catalog?: SkillCatalog | undefined;
+  };
+}
+interface CreateAgentSessionInput {
+  spec: AgentSpecId;
+  skills?: string[] | undefined;
+  auth?: AuthContext | null | undefined;
+  state?: Record<string, unknown> | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface CreateAgentAndRunInput extends CreateAgentSessionInput {
+  input: string | RunInput;
+}
+interface CreateRunInput {
+  agentId: AgentSessionId;
+  input: string | RunInput;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+  enqueue?: boolean | undefined;
+}
+interface AppendAgentMessageInput {
+  agentId: AgentSessionId;
+  content: string;
+  type?: "user.message" | "steering.message" | undefined;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+  schedule?: boolean | undefined;
+}
+interface AppendAgentMessageResult {
+  message: Message;
+  inboxEvent: InboxEvent;
+  message_id: MessageId;
+  inbox_event_id: InboxEventId;
+  scheduled: boolean;
+}
+interface AddMcpBindingInput {
+  agentId: AgentSessionId;
+  capabilityId: string;
+  accountRef?: string | null | undefined;
+  allowTools: McpAllowTools;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface RemoveMcpBindingInput {
+  agentId: AgentSessionId;
+  bindingId: McpBindingId;
+}
+interface CallToolInput {
+  toolId: string;
+  input?: unknown;
+  auth?: AuthContext | null | undefined;
+  approvalRequestId?: ApprovalRequestId | undefined;
+  signal?: AbortSignal | undefined;
+}
+interface ToolCallResult {
+  toolId: string;
+  result: unknown;
+  ok: true;
+}
+interface FailedToolCallResult {
+  toolId: string;
+  error: RunError;
+  ok: false;
+}
+type ToolCallAttemptResult = ToolCallResult | FailedToolCallResult;
+interface DeferToolResultInput {
+  runId: RunId;
+  toolId: string;
+  operationId?: DeferredToolOperationId | undefined;
+  toolCallId?: string | null | undefined;
+  resumePolicy?: DeferredToolResumePolicy | undefined;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}
+interface CompleteDeferredToolResultInput {
+  operationId: DeferredToolOperationId;
+  status?: "completed" | "failed" | "cancelled" | undefined;
+  result?: unknown;
+  content?: string | undefined;
+  error?: RunError | null | undefined;
+  auth?: AuthContext | null | undefined;
+  metadata?: Record<string, unknown> | undefined;
+  schedule?: boolean | undefined;
+}
+interface CompleteDeferredToolResultResult {
+  operation: DeferredToolOperation;
+  message: Message;
+  inboxEvent: InboxEvent | null;
+  scheduled: boolean;
+}
+interface CreateAgentAndRunResult {
+  agent: AgentSession;
+  run: Run;
+  message: Message | null;
+  inboxEvent: InboxEvent | null;
+  agent_id: AgentSessionId;
+  agent_spec_id: AgentSpecId;
+  run_id: RunId;
+}
+interface HephRuntime<TApp = unknown> {
+  stores: HephStores;
+  queue: QueueAdapter;
+  agents: {
+    create(input: CreateAgentSessionInput): Promise<AgentSession>;
+    createAndRun(input: CreateAgentAndRunInput): Promise<CreateAgentAndRunResult>;
+    appendMessage(input: AppendAgentMessageInput): Promise<AppendAgentMessageResult>;
+    schedule(agentId: AgentSessionId): Promise<Run | null>;
+    get(agentId: AgentSessionId): Promise<AgentSession | null>;
+    addMcpBinding(input: AddMcpBindingInput): Promise<McpBinding>;
+    listMcpBindings(agentId: AgentSessionId): Promise<McpBinding[]>;
+    removeMcpBinding(input: RemoveMcpBindingInput): Promise<McpBinding>;
+  };
+  runs: {
+    create(input: CreateRunInput): Promise<Run>;
+    get(runId: RunId): Promise<Run | null>;
+    cancel(runId: RunId): Promise<Run>;
+  };
+  messages: {
+    append(input: {
+      agentId: AgentSessionId;
+      role: "user" | "assistant" | "tool" | "developer" | "system";
+      content: string;
+      auth?: AuthContext | null | undefined;
+      metadata?: Record<string, unknown> | undefined;
+    }): Promise<Message>;
+    list(agentId: AgentSessionId, options?: {
+      limit?: number;
+    }): Promise<Message[]>;
+  };
+  approvals: {
+    get(approvalRequestId: ApprovalRequestId): Promise<ApprovalRequest | null>;
+    list(runId: RunId): Promise<ApprovalRequest[]>;
+    decide(input: {
+      approvalRequestId: ApprovalRequestId;
+      decision: "granted" | "rejected";
+      auth?: AuthContext | null | undefined;
+      metadata?: Record<string, unknown> | undefined;
+    }): Promise<ApprovalRequest>;
+  };
+  tools: {
+    call(runId: RunId, input: CallToolInput): Promise<ToolCallResult>;
+    tryCall(runId: RunId, input: CallToolInput): Promise<ToolCallAttemptResult>;
+  };
+  operations: {
+    deferToolResult(input: DeferToolResultInput): Promise<DeferredToolOperation>;
+    get(operationId: DeferredToolOperationId): Promise<DeferredToolOperation | null>;
+    complete(input: CompleteDeferredToolResultInput): Promise<CompleteDeferredToolResultResult>;
+  };
+  renderRunContext(runId: RunId): Promise<RenderedContext>;
+  handleJob(job: HephJob): Promise<void>;
+  startWorker(): Promise<void>;
+  drain(): Promise<void>;
+}
+declare class StreamableHttpMcpToolExecutor<TApp = unknown> implements McpToolExecutor<TApp> {
+  callTool(ctx: Parameters<McpToolExecutor<TApp>["callTool"]>[0]): Promise<unknown>;
+}
+declare function createHeph<TApp = unknown>(options: CreateHephOptions<TApp>): HephRuntime<TApp>;
+//#endregion
+//#region ../core/src/executor.d.ts
+interface RunExecutionContext<TApp = unknown> {
+  auth: AuthContext | null;
+  agent: AgentSession;
+  spec: AgentSpec$1<TApp>;
+  run: Run;
+  renderedContext: RenderedContext;
+  stores: HephStores;
+  app: TApp;
+  signal: AbortSignal;
+  emit(event: Omit<AppendRunEventInput, "runId">): Promise<void>;
+  appendMessage(input: Omit<AppendMessageInput, "agentId" | "auth">): Promise<Message>;
+  tools: {
+    call(input: CallToolInput): Promise<ToolCallResult>;
+    tryCall(input: CallToolInput): Promise<ToolCallAttemptResult>;
+  };
+  callTool(input: CallToolInput): Promise<ToolCallResult>;
+  tryCallTool(input: CallToolInput): Promise<ToolCallAttemptResult>;
+  deferToolResult(input: Omit<DeferToolResultInput, "runId"> & {
+    runId?: Run["id"];
+  }): Promise<DeferredToolOperation>;
+}
+interface RunExecutor<TApp = unknown> {
+  execute(ctx: RunExecutionContext<TApp>): Promise<void>;
+}
+declare class MinimalRunExecutor<TApp = unknown> implements RunExecutor<TApp> {
+  execute(ctx: RunExecutionContext<TApp>): Promise<void>;
+}
+//#endregion
+//#region ../core/src/ids.d.ts
+type IdPrefix = "agent_" | "run_" | "msg_" | "evt_" | "mem_" | "inbox_" | "op_" | "mcpbind_" | "skillbind_" | "approval_";
+declare function createId(prefix: IdPrefix): string;
+declare function createAgentSessionId(): string;
+declare function createRunId(): string;
+declare function createMessageId(): string;
+declare function createRunEventId(): string;
+declare function createMemoryId(): string;
+declare function createInboxEventId(): string;
+declare function createDeferredToolOperationId(): string;
+declare function createMcpBindingId(): string;
+declare function createSkillBindingId(): string;
+declare function createApprovalRequestId(): string;
+//#endregion
+//#region ../core/src/providers.d.ts
+interface RecentMessagesOptions {
+  limit?: number;
+}
+declare function recentMessages(options?: RecentMessagesOptions): ContextProvider$1;
+declare function threadState(): ContextProvider$1;
+interface MemorySearchOptions {
+  topK?: number;
+  scopes?: MemoryScope[];
+}
+declare function memorySearch(options?: MemorySearchOptions): ContextProvider$1;
+declare function block(block: ContextBlock): ContextBlock;
+//#endregion
+//#region ../core/src/skills.d.ts
+declare function createInMemorySkillCatalog(skills: SkillPackage[]): SkillCatalog;
+//#endregion
+//#region ../core/src/stores.d.ts
+declare class InMemoryHephStore implements StateStore, MessageStore, InboxStore, EventLog, MemoryStore, McpBindingStore, SkillBindingStore, ApprovalStore, DeferredToolOperationStore, HephStores {
+  readonly state: StateStore;
+  readonly messages: MessageStore;
+  readonly inbox: InboxStore;
+  readonly events: EventLog;
+  readonly memory: MemoryStore;
+  readonly mcpBindings: McpBindingStore;
+  readonly skillBindings: SkillBindingStore;
+  readonly approvals: ApprovalStore;
+  readonly deferredToolOperations: DeferredToolOperationStore;
+  private readonly agentSessions;
+  private readonly runs;
+  private readonly messageList;
+  private readonly inboxList;
+  private readonly inboxEvents;
+  private readonly eventList;
+  private readonly eventSeqByRun;
+  private readonly memoryItems;
+  private readonly mcpBindingList;
+  private readonly mcpBindingsById;
+  private readonly skillBindingList;
+  private readonly skillBindingsById;
+  private readonly approvalRequests;
+  private readonly deferredOperations;
+  createAgentSession(input: CreateAgentSessionStoreInput): Promise<AgentSession>;
+  getAgentSession(id: AgentSessionId): Promise<AgentSession | null>;
+  updateAgentSession(id: AgentSessionId, patch: Partial<Omit<AgentSession, "id" | "createdAt">>): Promise<AgentSession>;
+  createRun(input: CreateRunStoreInput): Promise<Run>;
+  getRun(id: RunId): Promise<Run | null>;
+  updateRun(id: RunId, patch: Partial<Omit<Run, "id" | "createdAt">>): Promise<Run>;
+  listRunsByAgent(agentId: AgentSessionId): Promise<Run[]>;
+  appendMessage(input: AppendMessageInput): Promise<Message>;
+  listMessages(agentId: AgentSessionId, options?: {
+    limit?: number;
+  }): Promise<Message[]>;
+  appendInboxEvent(input: AppendInboxEventInput): Promise<InboxEvent>;
+  getInboxEvent(id: InboxEventId): Promise<InboxEvent | null>;
+  listInboxEvents(agentId: AgentSessionId, options?: {
+    status?: InboxEventStatus;
+    types?: Array<InboxEvent["type"]>;
+    limit?: number;
+  }): Promise<InboxEvent[]>;
+  claimPendingInboxEvents(agentId: AgentSessionId, options?: {
+    types?: Array<InboxEvent["type"]>;
+    limit?: number;
+  }): Promise<InboxEvent[]>;
+  markInboxEventsProcessed(ids: InboxEventId[], runId: RunId): Promise<InboxEvent[]>;
+  markInboxEventsFailed(ids: InboxEventId[], error: RunError): Promise<InboxEvent[]>;
+  appendRunEvent(input: AppendRunEventInput): Promise<RunEvent>;
+  listRunEvents(runId: RunId, options?: {
+    after?: number;
+    limit?: number;
+  }): Promise<RunEvent[]>;
+  putMemory(input: PutMemoryInput): Promise<MemoryItem>;
+  searchMemory(input: SearchMemoryInput): Promise<MemoryItem[]>;
+  createMcpBinding(input: CreateMcpBindingStoreInput): Promise<McpBinding>;
+  getMcpBinding(id: McpBindingId): Promise<McpBinding | null>;
+  listMcpBindings(agentId: AgentSessionId, options?: {
+    status?: McpBindingStatus | "all" | undefined;
+  }): Promise<McpBinding[]>;
+  removeMcpBinding(id: McpBindingId): Promise<McpBinding>;
+  createSkillBinding(input: CreateSkillBindingStoreInput): Promise<SkillBinding>;
+  getSkillBinding(id: SkillBindingId): Promise<SkillBinding | null>;
+  listSkillBindings(agentId: AgentSessionId, options?: {
+    status?: SkillBindingStatus | "all" | undefined;
+  }): Promise<SkillBinding[]>;
+  removeSkillBinding(id: SkillBindingId): Promise<SkillBinding>;
+  createApprovalRequest(input: CreateApprovalRequestStoreInput): Promise<ApprovalRequest>;
+  getApprovalRequest(id: ApprovalRequestId): Promise<ApprovalRequest | null>;
+  listApprovalRequests(runId: RunId, options?: {
+    status?: ApprovalRequestStatus | "all" | undefined;
+  }): Promise<ApprovalRequest[]>;
+  decideApprovalRequest(input: DecideApprovalRequestStoreInput): Promise<ApprovalRequest>;
+  createDeferredToolOperation(input: CreateDeferredToolOperationStoreInput): Promise<DeferredToolOperation>;
+  getDeferredToolOperation(id: DeferredToolOperationId): Promise<DeferredToolOperation | null>;
+  completeDeferredToolOperation(input: CompleteDeferredToolOperationStoreInput): Promise<DeferredToolOperation>;
+  private replaceInboxEvent;
+  private getInboxEventOrThrow;
+  private replaceMcpBinding;
+  private replaceSkillBinding;
+}
+//#endregion
+export { HephErrorOptions as $, StateStore as $n, InboxEventStatus as $t, CallToolInput as A, ResolvedMcpBinding as An, ContextBlockType as At, HephRuntime as B, SkillAgentPolicy as Bn, CreateMcpBindingStoreInput as Bt, RunExecutor as C, MemoryStore as Cn, ApprovalRequestId as Ct, AgentSpecResolverContext as D, MessageStore as Dn, AuthContext as Dt, AgentSpecResolver as E, MessageRole as En, AuthAdapter as Et, CreateAgentSessionInput as F, RunEventType as Fn, ContextSlot as Ft, createHeph as G, SkillBindingStatus as Gn, DeferredToolOperationId as Gt, StreamableHttpMcpToolExecutor as H, SkillBinding as Hn, CreateSkillBindingStoreInput as Ht, CreateHephOptions as I, RunId as In, ContextTemplateMessage as It, InProcessQueue as J, SkillManifest as Jn, DeferredToolResumePolicy as Jt, EnqueueOptions as K, SkillBindingStore as Kn, DeferredToolOperationStatus as Kt, CreateRunInput as L, RunInput as Ln, CreateAgentSessionStoreInput as Lt, CompleteDeferredToolResultResult as M, RunError as Mn, ContextManifestBlock as Mt, CreateAgentAndRunInput as N, RunEvent as Nn, ContextProviderContext as Nt, AppendAgentMessageInput as O, PutMemoryInput as On, CompleteDeferredToolOperationStoreInput as Ot, CreateAgentAndRunResult as P, RunEventId as Pn, ContextProviderDefinition as Pt, HephErrorCode as Q, SourceRef as Qn, InboxEventId as Qt, DeferToolResultInput as R, RunStatus as Rn, CreateApprovalRequestStoreInput as Rt, RunExecutionContext as S, MemoryScope as Sn, ApprovalRequest as St, AgentSpecRegistration as T, MessageId as Tn, ApprovalStore as Tt, ToolCallAttemptResult as U, SkillBindingId as Un, DecideApprovalRequestStoreInput as Ut, RemoveMcpBindingInput as V, SkillAllowReferences as Vn, CreateRunStoreInput as Vt, ToolCallResult as W, SkillBindingSource as Wn, DeferredToolOperation as Wt, QueueAdapter as X, SkillPackage as Xn, HephStores as Xt, InProcessQueueOptions as Y, SkillManifestEntry as Yn, EventLog as Yt, HephError as Z, SkillResourceRef as Zn, InboxEvent as Zt, createMessageId as _, McpToolCallContext as _n, AgentSessionId as _t, block as a, LocalToolManifestTool as an, ToolManifestTool as ar, Tool as at, createSkillBindingId as b, MemoryId as bn, AppendMessageInput as bt, threadState as c, McpBinding as cn, defineContextTemplate as ct, createApprovalRequestId as d, McpBindingResolverContext as dn, ContextRendererOptions as dt, InboxStore as en, ToolConcurrencyKeyFn as er, isHephError as et, createDeferredToolOperationId as f, McpBindingStatus as fn, defaultContextTemplate as ft, createMemoryId as g, McpResolvedCredentials as gn, AgentSession as gt, createMcpBindingId as h, McpCredentialResolverContext as hn, AgentDefinition as ht, RecentMessagesOptions as i, JsonValue as in, ToolManifestSource as ir, ContextTemplate as it, CompleteDeferredToolResultInput as j, Run as jn, ContextManifest as jt, AppendAgentMessageResult as k, RenderedContext as kn, ContextBlock as kt, IdPrefix as l, McpBindingId as ln, defineTool as lt, createInboxEventId as m, McpCatalogTool as mn, messagesToText as mt, createInMemorySkillCatalog as n, JsonPrimitive as nn, ToolExecutionContext as nr, AgentSpec as nt, memorySearch as o, McpAgentPolicy as on, ToolManifestToolBase as or, defineAgent as ot, createId as p, McpBindingStore as pn, estimateTokens as pt, HephJob as q, SkillCatalog as qn, DeferredToolOperationStore as qt, MemorySearchOptions as r, JsonSchema as rn, ToolManifest as rr, ContextProvider as rt, recentMessages as s, McpAllowTools as sn, defineContextProvider as st, InMemoryHephStore as t, JsonObject as tn, ToolDefinition as tr, toErrorDetails as tt, createAgentSessionId as u, McpBindingResolver as un, ContextRenderer as ut, createRunEventId as v, McpToolExecutor as vn, AgentSpecId as vt, AddMcpBindingInput as w, Message as wn, ApprovalRequestStatus as wt, MinimalRunExecutor as x, MemoryItem as xn, AppendRunEventInput as xt, createRunId as y, McpToolManifestTool as yn, AppendInboxEventInput as yt, FailedToolCallResult as z, SearchMemoryInput as zn, CreateDeferredToolOperationStoreInput as zt };
+//# sourceMappingURL=index-CdsI9z7r.d.mts.map