@aaac/runtime 0.0.1 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,492 @@
1
+ import { z } from 'zod';
2
+ import { EmitInput, ExecutionEnvelope } from '@aaac/observability';
3
+
4
+ /**
5
+ * MemoryRef — opaque typed reference for resumable agent context.
6
+ *
7
+ * The ref itself is a lightweight pointer; the actual memory content
8
+ * is managed by the MemoryStore or held server-side by the provider.
9
+ */
10
+ interface MemoryRef {
11
+ /** Opaque identifier (e.g. session UUID, response ID, agent ID). */
12
+ id: string;
13
+ /** Provider that generated this ref (e.g. "claude-agent-sdk", "openai-responses"). */
14
+ provider: string;
15
+ /** Compatibility tag for format validation across versions. */
16
+ compat: string;
17
+ /** ISO 8601 timestamp of ref creation. */
18
+ created_at: string;
19
+ /** ID of the run that produced this ref, for chain tracking. */
20
+ parent_run_id?: string;
21
+ }
22
+ /**
23
+ * Pluggable store for memory content that backs MemoryRef pointers.
24
+ *
25
+ * Adapters that use server-side state (OpenAI, Gemini) may not need
26
+ * the store — the ref ID alone is sufficient for resume. Adapters
27
+ * with local state (Claude transcript, Gemini chat history) use the
28
+ * store to persist and retrieve content.
29
+ */
30
+ interface MemoryStore {
31
+ save(ref: MemoryRef, content: unknown): Promise<void>;
32
+ load(ref: MemoryRef): Promise<unknown | null>;
33
+ delete(ref: MemoryRef): Promise<void>;
34
+ }
35
+ /**
36
+ * In-memory store for testing. State is lost when the process exits.
37
+ */
38
+ declare class InMemoryStore implements MemoryStore {
39
+ private data;
40
+ save(ref: MemoryRef, content: unknown): Promise<void>;
41
+ load(ref: MemoryRef): Promise<unknown | null>;
42
+ delete(ref: MemoryRef): Promise<void>;
43
+ }
44
+
45
+ /**
46
+ * Candidate Agents — backend-neutral bridge for LLM-internal routing (model B)
47
+ *
48
+ * The runtime registers a set of *candidate sub-agents* with the SDK so the
49
+ * entry/main agent's LLM can delegate to them internally via the SDK's native
50
+ * subagent mechanism:
51
+ *
52
+ * - Claude `Options.agents: Record<string, AgentDefinition>`
53
+ * - OpenAI `Agent.handoffs: Agent[]`
54
+ * - ADK `LlmAgent.subAgents: BaseAgent[]`
55
+ *
56
+ * `CandidateAgent` is the common, SDK-independent contract. Each adapter maps it
57
+ * onto its provider's native shape. The selection rule (which agents become
58
+ * candidates) lives here so all adapters stay backend-agnostic.
59
+ */
60
+
61
+ /**
62
+ * SDK-independent description of a sub-agent the entry agent's LLM may delegate
63
+ * to. Adapters translate this into their provider's native subagent shape.
64
+ */
65
+ interface CandidateAgent {
66
+ /** Agent id (used as the SDK subagent key / name). */
67
+ name: string;
68
+ /** When to use this agent — the routing hint shown to the delegating LLM. */
69
+ description: string;
70
+ /** The agent's system prompt (role / purpose / responsibilities / constraints / rules). */
71
+ prompt: string;
72
+ /** Optional allowed tool names (omit to inherit from the parent agent). */
73
+ tools?: string[];
74
+ /** Optional model id (omit to inherit from the parent agent). */
75
+ model?: string;
76
+ }
77
+ /**
78
+ * Render an agent contract into its system-prompt string: the static
79
+ * Role / Responsibilities / Constraints / Rules sections.
80
+ *
81
+ * Shared by `buildSplitTaskPrompt` (entry agent system prompt) and
82
+ * `buildCandidateAgents` (each candidate's `prompt`) so both stay in sync.
83
+ */
84
+ declare function renderAgentSystemPrompt(agent: AgentContractLike): string;
85
+ interface BuildCandidateAgentsOptions {
86
+ /** The entry/main agent id. Excluded from the candidate set. */
87
+ entryAgentId?: string;
88
+ /**
89
+ * When provided (typically the entry agent's `can_invoke_agents`), restrict
90
+ * candidates to these agent ids. Omit to allow every non-entry agent.
91
+ */
92
+ allowedAgentIds?: readonly string[];
93
+ }
94
+ /**
95
+ * Build the candidate sub-agent set from an agent registry.
96
+ *
97
+ * Selection rule: every agent EXCEPT the entry agent; if `allowedAgentIds` is
98
+ * given, further restrict to that allow-list.
99
+ */
100
+ declare function buildCandidateAgents(agentRegistry: Record<string, AgentContractLike>, opts?: BuildCandidateAgentsOptions): CandidateAgent[];
101
+
102
+ /**
103
+ * observability-bridge.ts
104
+ *
105
+ * Bridge between @aaac/runtime execution and @aaac/observability agent-axis spans.
106
+ *
107
+ * Responsibilities:
108
+ * - Generate ExecutionEnvelope (run_id = UUIDv7) for every task/workflow execution
109
+ * - Emit agent.session (open/close) for runWorkflow() — root run span
110
+ * - Emit agent.subagent (open/close) for runTask() — handoff/task span
111
+ * - Observer is OPTIONAL — all emit* functions are no-ops when observer is undefined
112
+ *
113
+ * No circular dependency: @aaac/observability does NOT import @aaac/runtime.
114
+ * Types (ExecutionEnvelope, EmitInput) are consumed from @aaac/observability.
115
+ *
116
+ * event-catalog.md §1.5, §2.2 / OBSERVABILITY_TASKS.md Phase 1 / architecture.md §6, §7
117
+ */
118
+
119
+ /**
120
+ * Minimal observer emit signature — structurally matches EventCollector.emit().
121
+ * Pass `collector.emit.bind(collector)` to wire up the full observability pipeline.
122
+ * When undefined, all emission is a no-op.
123
+ */
124
+ type ObserverEmitFn = (event: EmitInput) => void;
125
+ interface EnvelopeParams {
126
+ /** run_id of the parent execution (populated by workflow-runner for task spans). */
127
+ parentRunId?: string;
128
+ /** Component / agent identifier from the agent-contracts definition. */
129
+ componentId?: string;
130
+ /** Agent that issued this execution (handoff source). */
131
+ fromAgent?: string;
132
+ /** Agent that receives this execution (handoff target). */
133
+ toAgent?: string;
134
+ /** agent-contracts schema version. */
135
+ contractVersion?: string;
136
+ /** LLM adapter identifier (e.g. 'claude-agent-sdk'). */
137
+ adapter?: string;
138
+ /** LLM model identifier (e.g. 'claude-opus-4-5'). */
139
+ model?: string;
140
+ /** Task instance identifier within the run. */
141
+ taskInstanceId?: string;
142
+ }
143
+ /**
144
+ * Create an ExecutionEnvelope with a fresh UUIDv7 run_id and current timestamp.
145
+ * Only defined fields are included — undefined values are omitted.
146
+ */
147
+ declare function createExecutionEnvelope(params?: EnvelopeParams): ExecutionEnvelope;
148
+ /**
149
+ * Emit an agent.session open span (root workflow/session execution).
150
+ *
151
+ * Uses envelope.run_id as the spanId so that child agent.subagent spans can
152
+ * reference it as parentSpanId for hierarchical correlation.
153
+ *
154
+ * Returns the spanId emitted (= envelope.run_id).
155
+ * Returns undefined when observer is undefined (no-op).
156
+ *
157
+ * event-catalog.md §2.2 — required: agent.session_id; axis: agent
158
+ */
159
+ declare function emitSessionOpen(observer: ObserverEmitFn | undefined, envelope: ExecutionEnvelope, workflowId: string): string | undefined;
160
+ /**
161
+ * Emit an agent.session close span.
162
+ *
163
+ * event-catalog.md §2.2 — optional: agent.session.duration_ms, agent.status
164
+ */
165
+ declare function emitSessionClose(observer: ObserverEmitFn | undefined, spanId: string, envelope: ExecutionEnvelope, durationMs: number, status: string): void;
166
+ /**
167
+ * Emit an agent.subagent open span (task/handoff execution).
168
+ *
169
+ * Uses envelope.run_id as the spanId and parentSpanId for hierarchical correlation
170
+ * (typically the session span's run_id).
171
+ *
172
+ * Returns the spanId emitted (= envelope.run_id).
173
+ * Returns undefined when observer is undefined (no-op).
174
+ *
175
+ * event-catalog.md §2.2 — required: agent.role; axis: agent
176
+ */
177
+ declare function emitSubagentOpen(observer: ObserverEmitFn | undefined, envelope: ExecutionEnvelope, parentSpanId: string | undefined, taskId: string, agentRole: string): string | undefined;
178
+ /**
179
+ * Emit an agent.subagent close span.
180
+ *
181
+ * event-catalog.md §2.2 — optional: agent.duration_ms, agent.status, token_usage, cost_usd
182
+ */
183
+ declare function emitSubagentClose(observer: ObserverEmitFn | undefined, spanId: string, envelope: ExecutionEnvelope, durationMs: number, status: string, agentRole: string): void;
184
+
185
+ /**
186
+ * Task Runner — runs a single DSL task via an SDK agent
187
+ *
188
+ * Responsibilities:
189
+ * 1. Resolve task contract → target agent contract
190
+ * 2. Build the agent prompt from contract + context
191
+ * 3. Apply plugin prompt enhancers and beforeTask hooks
192
+ * 4. Send to SDK agent (via abstract SdkAdapter) and stream result
193
+ * 5. Parse + validate result against handoff schema
194
+ * 6. Apply plugin afterTask hooks
195
+ * 7. Return typed result or escalation signal
196
+ *
197
+ * Two recovery strategies:
198
+ * - followUp: lightweight, same session — fix output format only
199
+ * - retry: heavyweight, new session — re-execute entire task
200
+ */
201
+
202
+ interface AgentContractLike {
203
+ readonly id: string;
204
+ readonly role_name: string;
205
+ readonly purpose: string;
206
+ readonly mode: "read-write" | "read-only";
207
+ readonly responsibilities: readonly string[];
208
+ readonly constraints: readonly string[];
209
+ readonly rules?: readonly {
210
+ readonly id: string;
211
+ readonly description: string;
212
+ readonly severity: string;
213
+ }[];
214
+ /**
215
+ * Agent ids this agent is allowed to delegate to. When present, it restricts
216
+ * the candidate sub-agent set registered with the SDK for LLM-internal routing.
217
+ */
218
+ readonly can_invoke_agents?: readonly string[];
219
+ /**
220
+ * Tool names this agent may execute. When present, sub-agents receive an
221
+ * isolated tool set instead of inheriting the parent agent's tools.
222
+ */
223
+ readonly can_execute_tools?: readonly string[];
224
+ }
225
+ interface TaskContractLike {
226
+ readonly id: string;
227
+ readonly description: string;
228
+ readonly target_agent: string;
229
+ readonly result_handoff: string;
230
+ readonly completion_criteria: readonly string[];
231
+ readonly model_class?: "fast" | "standard" | "thinking";
232
+ /**
233
+ * When true, the adapter may enable Dynamic Workflow tools (e.g. Claude's
234
+ * Workflow tool) so the agent can internally parallelise sub-tasks.
235
+ * Handoff validation at the task boundary is still enforced.
236
+ */
237
+ readonly allow_dynamic_workflow?: boolean;
238
+ }
239
+ /**
240
+ * Progress event emitted by adapters during agent execution.
241
+ * Enables real-time visibility into what the agent is doing
242
+ * (tool calls, text output, status changes).
243
+ */
244
+ interface AgentProgressEvent {
245
+ type: "tool_use" | "tool_result" | "text" | "status" | "cache_metrics";
246
+ tool_name?: string;
247
+ /** Tool invocation arguments (e.g. file path, command). */
248
+ input?: Record<string, unknown>;
249
+ message?: string;
250
+ /** SDK session ID for correlating events within a single adapter call. */
251
+ session_id?: string;
252
+ /** Cache utilization metrics from the SDK response. */
253
+ cacheMetrics?: {
254
+ cachedInputTokens?: number;
255
+ totalInputTokens?: number;
256
+ };
257
+ }
258
+ /**
259
+ * A prompt split into static (cacheable) and dynamic (per-invocation) sections.
260
+ * Adapters that support prompt caching can use the `system` sections as
261
+ * provider-specific system prompts, reducing token costs on repeated calls.
262
+ */
263
+ interface SplitPrompt {
264
+ /** Static sections: role, responsibilities, constraints, rules, task, schema, recovery. */
265
+ system: string[];
266
+ /** Dynamic sections: user request, handoff input, prior context, files, acceptance criteria. */
267
+ user: string;
268
+ }
269
+ /**
270
+ * Optional cache configuration for adapters that support prompt caching.
271
+ * Provider-specific defaults apply when individual fields are omitted.
272
+ */
273
+ interface CacheConfig {
274
+ /** Enable prompt caching. Defaults to true when the adapter supports it. */
275
+ enabled?: boolean;
276
+ /** Provider-specific TTL (e.g. "5m", "1h", "24h"). */
277
+ ttl?: string;
278
+ /** Stable key for cross-session cache reuse (provider-specific). */
279
+ cacheKey?: string;
280
+ }
281
+ /**
282
+ * Base options for SdkAdapter.send(). SDK-specific options (model, cwd,
283
+ * sessionMode, etc.) belong on the adapter constructor / factory — not here.
284
+ */
285
+ interface AdapterSendOptions {
286
+ readonly: boolean;
287
+ /**
288
+ * Optional callback invoked with intermediate progress events during execution.
289
+ * Adapters that consume an internal event stream (e.g. Claude SDK's AsyncGenerator)
290
+ * call this for each non-result message, enabling callers to display live progress.
291
+ */
292
+ onProgress?: (event: AgentProgressEvent) => void;
293
+ /**
294
+ * Split prompt for prompt caching support. When provided, adapters that support
295
+ * caching can separate static (cacheable) instructions from dynamic content.
296
+ * Adapters without caching support can ignore this and use the prompt argument.
297
+ */
298
+ splitPrompt?: SplitPrompt;
299
+ /**
300
+ * Candidate sub-agents the entry agent's LLM may delegate to (model B,
301
+ * LLM-internal routing). Adapters register these via their native subagent
302
+ * mechanism (Claude `agents`, OpenAI `handoffs`, ADK `subAgents`). When
303
+ * omitted or empty, adapters behave exactly as before (single agent).
304
+ */
305
+ agents?: CandidateAgent[];
306
+ /**
307
+ * When true, adapters that support dynamic workflow tools (e.g. Claude's
308
+ * Workflow tool for agent()/pipeline()/parallel()) should enable them.
309
+ * The task's final output is still validated against the handoff schema.
310
+ */
311
+ allowDynamicWorkflow?: boolean;
312
+ }
313
+ /**
314
+ * Rich execution request for adapters that need more than a prompt string.
315
+ * Adapters can implement sendExecution() to receive full contract context.
316
+ */
317
+ interface AgentExecutionRequest {
318
+ agentId: string;
319
+ taskId: string;
320
+ prompt: string;
321
+ handoff?: {
322
+ type: string;
323
+ payload: unknown;
324
+ };
325
+ schema?: {
326
+ handoffType: string;
327
+ zodSchema: unknown;
328
+ promptDescription: string;
329
+ };
330
+ context: TaskContext;
331
+ /** Resumable memory reference from a previous run. */
332
+ memoryRef?: MemoryRef;
333
+ /**
334
+ * Split prompt for prompt caching support. When provided, adapters can
335
+ * separate static instructions (system) from dynamic content (user).
336
+ */
337
+ splitPrompt?: SplitPrompt;
338
+ /**
339
+ * Candidate sub-agents for LLM-internal routing (model B). Mirrors
340
+ * `AdapterSendOptions.agents`; also forwarded via `options.agents`.
341
+ */
342
+ agents?: CandidateAgent[];
343
+ options: AdapterSendOptions & {
344
+ maxFollowUps: number;
345
+ attempt: number;
346
+ };
347
+ }
348
+ interface SdkAdapter {
349
+ /** Start a new task session and return the full text response. */
350
+ send(prompt: string, options: AdapterSendOptions): Promise<string>;
351
+ /**
352
+ * Send a follow-up message within the same agent session.
353
+ * Used for output-format corrections without re-executing the task.
354
+ * Falls back to send() if not implemented (stateless adapters like mock).
355
+ */
356
+ followUp?(message: string): Promise<string>;
357
+ /**
358
+ * Rich execution path. When implemented, the runtime prefers this over
359
+ * send() and passes the full contract context. Adapters that only need
360
+ * a prompt string can ignore this — the runtime falls back to send().
361
+ */
362
+ sendExecution?(request: AgentExecutionRequest): Promise<string>;
363
+ /** Return the memory_ref produced by the last send/sendExecution call. */
364
+ getLastMemoryRef?(): MemoryRef | null;
365
+ /** Check if this adapter is compatible with the given compat tag. */
366
+ isCompatible?(compat: string): boolean;
367
+ }
368
+ interface TaskContext {
369
+ user_request: string;
370
+ prior_context?: string;
371
+ relevant_paths?: string[];
372
+ acceptance_criteria?: string[];
373
+ /**
374
+ * Structured handoff input (primary data). When present, prompt builders
375
+ * should derive the prompt from this rather than user_request alone.
376
+ */
377
+ handoff_input?: {
378
+ type: string;
379
+ version?: number;
380
+ payload: unknown;
381
+ };
382
+ /** Arbitrary structured variables plugins or workflow context may inject. */
383
+ variables?: Record<string, unknown>;
384
+ /** Resumable memory reference from a previous run. */
385
+ memoryRef?: MemoryRef;
386
+ }
387
+ type TaskOutcome = {
388
+ status: "success";
389
+ data: unknown;
390
+ raw: string;
391
+ memoryRef?: MemoryRef;
392
+ } | {
393
+ status: "validation_error";
394
+ errors: z.ZodError;
395
+ raw: string;
396
+ } | {
397
+ status: "escalation";
398
+ reason: string;
399
+ raw: string;
400
+ } | {
401
+ status: "error";
402
+ message: string;
403
+ };
404
+ /**
405
+ * Retry strategy decision.
406
+ *
407
+ * - "follow_up": lightweight — same session, fix output format only
408
+ * - "retry": heavyweight — new send(), re-execute the entire task
409
+ * - "abort": stop retrying, return the current outcome
410
+ */
411
+ type RetryDecision = "follow_up" | "retry" | "abort";
412
+ interface TaskRunOptions {
413
+ /** Max follow-up attempts (output format correction, same session). Default: 2 */
414
+ maxFollowUps?: number;
415
+ /** Max full retry attempts (re-execute entire task via send). Default: 0 */
416
+ maxRetries?: number;
417
+ /**
418
+ * Called on each failure to decide which recovery strategy to use.
419
+ * Default: validation_error → follow_up, empty output → retry, else abort.
420
+ */
421
+ decideRetryStrategy?: (outcome: TaskOutcome, counts: {
422
+ followUps: number;
423
+ retries: number;
424
+ }) => Promise<RetryDecision> | RetryDecision;
425
+ /**
426
+ * Writable stream for real-time progress output during agent execution.
427
+ * When provided, intermediate adapter events (tool use, status, etc.)
428
+ * are formatted and written here. Typical value: process.stderr.
429
+ */
430
+ progressOutput?: {
431
+ write(chunk: string): unknown;
432
+ };
433
+ /**
434
+ * Optional observer emit function for agent-axis spans (agent.subagent open/close).
435
+ * When undefined, no spans are emitted (observer is optional — no-op).
436
+ * Pass EventCollector.emit.bind(collector) to wire the full observability pipeline.
437
+ */
438
+ observer?: ObserverEmitFn;
439
+ /**
440
+ * Parent span ID (typically the enclosing agent.session span's run_id).
441
+ * Used to correlate agent.subagent spans with their parent session.
442
+ */
443
+ parentSpanId?: string;
444
+ }
445
+ interface TaskRunResult {
446
+ outcome: TaskOutcome;
447
+ follow_ups_used: number;
448
+ retries_used: number;
449
+ }
450
+ /**
451
+ * Convert a Zod schema into a human-readable field table for inclusion in LLM prompts.
452
+ * Recursively generates sub-tables for nested objects and array elements.
453
+ */
454
+ declare function zodSchemaToPromptDescription(schema: z.ZodType): string;
455
+ /**
456
+ * Generate a YAML example from a Zod schema shape, recursively expanding
457
+ * nested objects and arrays up to a configurable depth.
458
+ */
459
+ declare function zodSchemaToYamlExample(schema: z.ZodType, maxDepth?: number): string;
460
+ interface PromptBuilderOptions {
461
+ handoffSchemas?: Record<string, z.ZodType>;
462
+ retry?: {
463
+ condition: string;
464
+ fix_task: string;
465
+ revalidate_task?: string;
466
+ };
467
+ }
468
+ /**
469
+ * Build a prompt split into static (cacheable) and dynamic (per-invocation) parts.
470
+ *
471
+ * Static (system): Role, Responsibilities, Constraints, Rules, Task description,
472
+ * Completion Criteria, Output Format / Schema, Recovery Instructions.
473
+ *
474
+ * Dynamic (user): User Request, Handoff Input, Prior Context,
475
+ * Relevant Files, Acceptance Criteria.
476
+ */
477
+ declare function buildSplitTaskPrompt(agent: AgentContractLike, task: TaskContractLike, context: TaskContext, options?: PromptBuilderOptions): SplitPrompt;
478
+ declare function buildTaskPrompt(agent: AgentContractLike, task: TaskContractLike, context: TaskContext, options?: PromptBuilderOptions): string;
479
+ declare function extractStructuredResult(raw: string): unknown | null;
480
+ declare function buildRetryFollowUp(task: TaskContractLike, lastOutcome: TaskOutcome, options?: PromptBuilderOptions): string;
481
+ declare function runTask(adapter: SdkAdapter, taskId: string, context: TaskContext, options?: TaskRunOptions & {
482
+ agentRegistry?: Record<string, AgentContractLike>;
483
+ taskRegistry?: Record<string, TaskContractLike>;
484
+ handoffSchemas?: Record<string, z.ZodType>;
485
+ retry?: {
486
+ condition: string;
487
+ fix_task: string;
488
+ revalidate_task?: string;
489
+ };
490
+ }): Promise<TaskRunResult>;
491
+
492
+ export { type AdapterSendOptions as A, type CacheConfig as C, type EnvelopeParams as E, InMemoryStore as I, type MemoryRef as M, type ObserverEmitFn as O, type PromptBuilderOptions as P, type RetryDecision as R, type SdkAdapter as S, type TaskOutcome as T, type AgentExecutionRequest as a, type TaskContractLike as b, type AgentContractLike as c, type TaskContext as d, type MemoryStore as e, type TaskRunResult as f, type AgentProgressEvent as g, type CandidateAgent as h, type SplitPrompt as i, type TaskRunOptions as j, buildCandidateAgents as k, buildRetryFollowUp as l, buildSplitTaskPrompt as m, buildTaskPrompt as n, createExecutionEnvelope as o, emitSessionClose as p, emitSessionOpen as q, emitSubagentClose as r, emitSubagentOpen as s, extractStructuredResult as t, renderAgentSystemPrompt as u, runTask as v, zodSchemaToYamlExample as w, zodSchemaToPromptDescription as z };
package/package.json CHANGED
@@ -1,14 +1,34 @@
1
1
  {
2
2
  "name": "@aaac/runtime",
3
- "version": "0.0.1",
3
+ "version": "0.1.0",
4
4
  "description": "Runtime SDK for the AAAC toolchain",
5
5
  "type": "module",
6
6
  "main": "dist/index.js",
7
7
  "types": "dist/index.d.ts",
8
8
  "exports": {
9
9
  ".": {
10
- "import": "./dist/index.js",
11
- "types": "./dist/index.d.ts"
10
+ "types": "./dist/index.d.ts",
11
+ "import": "./dist/index.js"
12
+ },
13
+ "./adapters/claude-agent-sdk": {
14
+ "types": "./dist/adapters/claude-agent-sdk.d.ts",
15
+ "import": "./dist/adapters/claude-agent-sdk.js"
16
+ },
17
+ "./adapters/openai-agents-sdk": {
18
+ "types": "./dist/adapters/openai-agents-sdk.d.ts",
19
+ "import": "./dist/adapters/openai-agents-sdk.js"
20
+ },
21
+ "./adapters/adk-sdk": {
22
+ "types": "./dist/adapters/adk-sdk.d.ts",
23
+ "import": "./dist/adapters/adk-sdk.js"
24
+ },
25
+ "./adapters/mock": {
26
+ "types": "./dist/adapters/mock.d.ts",
27
+ "import": "./dist/adapters/mock.js"
28
+ },
29
+ "./generator": {
30
+ "types": "./dist/generator/index.d.ts",
31
+ "import": "./dist/generator/index.js"
12
32
  }
13
33
  },
14
34
  "files": [
@@ -32,6 +52,33 @@
32
52
  "author": "foo-log-inc",
33
53
  "license": "MIT",
34
54
  "engines": {
35
- "node": ">=20.0.0"
55
+ "node": ">=22.0.0"
56
+ },
57
+ "dependencies": {
58
+ "@aaac/contracts": "*",
59
+ "@aaac/observability": "*",
60
+ "agent-contracts": "^0.35.0",
61
+ "commander": "^12.1.0",
62
+ "dotenv": "^17.4.2",
63
+ "handlebars": "^4.7.9",
64
+ "tsx": "^4.21.0",
65
+ "yaml": "^2.8.3",
66
+ "zod": "^4.0.0"
67
+ },
68
+ "peerDependencies": {
69
+ "@anthropic-ai/claude-agent-sdk": ">=0.2.0",
70
+ "@google/adk": ">=1.2.0",
71
+ "@openai/agents": ">=0.10.0"
72
+ },
73
+ "peerDependenciesMeta": {
74
+ "@google/adk": {
75
+ "optional": true
76
+ },
77
+ "@anthropic-ai/claude-agent-sdk": {
78
+ "optional": true
79
+ },
80
+ "@openai/agents": {
81
+ "optional": true
82
+ }
36
83
  }
37
84
  }