runwarden 0.0.0-stage → 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,1232 @@
1
+ import { LanguageModel } from "ai";
2
+ import { z } from "zod";
3
+ import { NodePgDatabase } from "drizzle-orm/node-postgres";
4
+ import { Pool } from "pg";
5
+ interface ToolDefinition {
6
+ name: string;
7
+ description: string;
8
+ inputSchema: z.ZodType;
9
+ validateInput?: (input: unknown) => {
10
+ ok: true;
11
+ } | {
12
+ ok: false;
13
+ correction: string;
14
+ };
15
+ }
16
+ interface McpServerConfig {
17
+ name: string;
18
+ url: string;
19
+ headers?: Record<string, string>;
20
+ tools?: string[];
21
+ }
22
+ type PolicyRule = 'exactly_one' | 'max_tool_calls' | 'allowlist' | 'require_approval' | 'input_validation' | 'correction_budget';
23
+ type PolicyDecisionKind = 'allow' | 'deny' | 'correction_issued' | 'approval_requested' | 'approved' | 'rejected';
24
+ interface PolicyDecision {
25
+ scope: string;
26
+ invocationId: string;
27
+ runId: string;
28
+ rule: PolicyRule;
29
+ decision: PolicyDecisionKind;
30
+ toolName?: string;
31
+ detail?: Record<string, unknown>;
32
+ }
33
+ interface RuntimePolicies {
34
+ exactlyOneToolCallPerStep?: boolean;
35
+ correctionBudget?: number;
36
+ maxToolCallsPerInvocation?: number;
37
+ maxDurationMs?: number;
38
+ toolAllowlist?: string[] | ((scope: string) => string[] | undefined);
39
+ requireApproval?: string[];
40
+ maxToolResultBytes?: number;
41
+ }
42
+ type AgentRuntimeErrorKind = 'timeout' | 'failure';
43
+ export declare class AgentRuntimeError extends Error {
44
+ readonly kind: AgentRuntimeErrorKind;
45
+ readonly diagnostics: Record<string, unknown>;
46
+ constructor(kind: AgentRuntimeErrorKind, message: string, diagnostics?: Record<string, unknown>, options?: ErrorOptions);
47
+ }
48
+ interface InvocationInput {
49
+ scope: string;
50
+ prompt: string;
51
+ conversationId?: string;
52
+ orderingKey?: string;
53
+ context?: Record<string, unknown>;
54
+ idempotencyKey?: string;
55
+ maxAttempts?: number;
56
+ metadata?: Record<string, unknown>;
57
+ }
58
+ interface InvocationResult {
59
+ invocationId: string;
60
+ runId: string;
61
+ text: string;
62
+ provider?: string;
63
+ model?: string;
64
+ }
65
+ interface PendingToolCall {
66
+ toolName: string;
67
+ input: unknown;
68
+ }
69
+ type InvocationStatus = 'pending' | 'running' | 'awaiting_approval' | 'succeeded' | 'failed' | 'cancelled';
70
+ interface InvocationRecord extends InvocationInput {
71
+ id: string;
72
+ status: InvocationStatus;
73
+ attemptCount: number;
74
+ resultText?: string;
75
+ pendingToolCall?: PendingToolCall;
76
+ lastErrorCode?: string;
77
+ lastErrorMessage?: string;
78
+ createdAt: Date;
79
+ completedAt?: Date;
80
+ }
81
+ interface NeutralMessage {
82
+ role: 'user' | 'assistant' | 'system';
83
+ content: string;
84
+ }
85
+ type RuntimeInvocationInput = InvocationInput & {
86
+ invocationId: string;
87
+ runId: string;
88
+ approvedToolCall?: PendingToolCall;
89
+ };
90
+ interface AgentRuntime {
91
+ invoke(input: RuntimeInvocationInput): Promise<InvocationResult>;
92
+ }
93
+ type SystemPromptLoader = (input: RuntimeInvocationInput) => Promise<string>;
94
+ type HistoryLoader = (input: RuntimeInvocationInput) => Promise<readonly NeutralMessage[]>;
95
+ interface McpToolSession {
96
+ callTool(input: {
97
+ name: string;
98
+ arguments: Record<string, unknown>;
99
+ timeoutMs: number;
100
+ idempotencyKey?: string;
101
+ }): Promise<string>;
102
+ close(): Promise<void>;
103
+ }
104
+ interface ToolCallAuditEvent {
105
+ dispatchId: string;
106
+ phase: 'started' | 'succeeded' | 'failed';
107
+ scope: string;
108
+ invocationId: string;
109
+ runId: string;
110
+ toolName: string;
111
+ toolCallId?: string;
112
+ idempotencyKey: string;
113
+ input: unknown;
114
+ errorCode?: string;
115
+ }
116
+ type ToolCallAuditSink = (event: ToolCallAuditEvent) => Promise<void> | void;
117
+ interface McpToolClient {
118
+ open(input: {
119
+ runId: string;
120
+ timeoutMs: number;
121
+ }): Promise<McpToolSession>;
122
+ }
123
+ interface RuntimeMetrics {
124
+ runId: string;
125
+ contextLoadMs: number;
126
+ historyLoadMs: number;
127
+ providerCallCount: number;
128
+ toolCallCount: number;
129
+ totalProviderMs: number;
130
+ totalToolMs: number;
131
+ totalMs: number;
132
+ }
133
+ declare namespace schema_d_exports {
134
+ export { InvocationRow, PolicyDecisionRow, ToolCallStatus, invocationStatusEnum, invocations, policyDecisions, runtimeSchema, toolCallAudits, toolCallStatusEnum, workerLeases };
135
+ }
136
+ declare const runtimeSchema: import("drizzle-orm/pg-core").PgSchema<"agent_runtime">;
137
+ declare const invocationStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "running", "awaiting_approval", "succeeded", "failed", "cancelled"]>;
138
+ declare const toolCallStatusEnum: import("drizzle-orm/pg-core").PgEnum<["started", "succeeded", "failed"]>;
139
+ type ToolCallStatus = (typeof toolCallStatusEnum.enumValues)[number];
140
+ declare const invocations: import("drizzle-orm/pg-core").PgTableWithColumns<{
141
+ name: "invocations";
142
+ schema: "agent_runtime";
143
+ columns: {
144
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
145
+ name: "created_at";
146
+ tableName: "invocations";
147
+ dataType: "date";
148
+ columnType: "PgTimestamp";
149
+ data: Date;
150
+ driverParam: string;
151
+ notNull: true;
152
+ hasDefault: true;
153
+ isPrimaryKey: false;
154
+ isAutoincrement: false;
155
+ hasRuntimeDefault: false;
156
+ enumValues: undefined;
157
+ baseColumn: never;
158
+ identity: undefined;
159
+ generated: undefined;
160
+ }, {}, {}>;
161
+ updatedAt: import("drizzle-orm/pg-core").PgColumn<{
162
+ name: "updated_at";
163
+ tableName: "invocations";
164
+ dataType: "date";
165
+ columnType: "PgTimestamp";
166
+ data: Date;
167
+ driverParam: string;
168
+ notNull: true;
169
+ hasDefault: true;
170
+ isPrimaryKey: false;
171
+ isAutoincrement: false;
172
+ hasRuntimeDefault: false;
173
+ enumValues: undefined;
174
+ baseColumn: never;
175
+ identity: undefined;
176
+ generated: undefined;
177
+ }, {}, {}>;
178
+ id: import("drizzle-orm/pg-core").PgColumn<{
179
+ name: "id";
180
+ tableName: "invocations";
181
+ dataType: "number";
182
+ columnType: "PgBigInt53";
183
+ data: number;
184
+ driverParam: string | number;
185
+ notNull: true;
186
+ hasDefault: true;
187
+ isPrimaryKey: true;
188
+ isAutoincrement: false;
189
+ hasRuntimeDefault: false;
190
+ enumValues: undefined;
191
+ baseColumn: never;
192
+ identity: "always";
193
+ generated: undefined;
194
+ }, {}, {}>;
195
+ scope: import("drizzle-orm/pg-core").PgColumn<{
196
+ name: "scope";
197
+ tableName: "invocations";
198
+ dataType: "string";
199
+ columnType: "PgText";
200
+ data: string;
201
+ driverParam: string;
202
+ notNull: true;
203
+ hasDefault: false;
204
+ isPrimaryKey: false;
205
+ isAutoincrement: false;
206
+ hasRuntimeDefault: false;
207
+ enumValues: [string, ...string[]];
208
+ baseColumn: never;
209
+ identity: undefined;
210
+ generated: undefined;
211
+ }, {}, {}>;
212
+ conversationId: import("drizzle-orm/pg-core").PgColumn<{
213
+ name: "conversation_id";
214
+ tableName: "invocations";
215
+ dataType: "string";
216
+ columnType: "PgText";
217
+ data: string;
218
+ driverParam: string;
219
+ notNull: false;
220
+ hasDefault: false;
221
+ isPrimaryKey: false;
222
+ isAutoincrement: false;
223
+ hasRuntimeDefault: false;
224
+ enumValues: [string, ...string[]];
225
+ baseColumn: never;
226
+ identity: undefined;
227
+ generated: undefined;
228
+ }, {}, {}>;
229
+ orderingKey: import("drizzle-orm/pg-core").PgColumn<{
230
+ name: "ordering_key";
231
+ tableName: "invocations";
232
+ dataType: "string";
233
+ columnType: "PgText";
234
+ data: string;
235
+ driverParam: string;
236
+ notNull: false;
237
+ hasDefault: false;
238
+ isPrimaryKey: false;
239
+ isAutoincrement: false;
240
+ hasRuntimeDefault: false;
241
+ enumValues: [string, ...string[]];
242
+ baseColumn: never;
243
+ identity: undefined;
244
+ generated: undefined;
245
+ }, {}, {}>;
246
+ input: import("drizzle-orm/pg-core").PgColumn<{
247
+ name: "input";
248
+ tableName: "invocations";
249
+ dataType: "json";
250
+ columnType: "PgJsonb";
251
+ data: InvocationInput;
252
+ driverParam: unknown;
253
+ notNull: true;
254
+ hasDefault: false;
255
+ isPrimaryKey: false;
256
+ isAutoincrement: false;
257
+ hasRuntimeDefault: false;
258
+ enumValues: undefined;
259
+ baseColumn: never;
260
+ identity: undefined;
261
+ generated: undefined;
262
+ }, {}, {
263
+ $type: InvocationInput;
264
+ }>;
265
+ resultText: import("drizzle-orm/pg-core").PgColumn<{
266
+ name: "result_text";
267
+ tableName: "invocations";
268
+ dataType: "string";
269
+ columnType: "PgText";
270
+ data: string;
271
+ driverParam: string;
272
+ notNull: false;
273
+ hasDefault: false;
274
+ isPrimaryKey: false;
275
+ isAutoincrement: false;
276
+ hasRuntimeDefault: false;
277
+ enumValues: [string, ...string[]];
278
+ baseColumn: never;
279
+ identity: undefined;
280
+ generated: undefined;
281
+ }, {}, {}>;
282
+ idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
283
+ name: "idempotency_key";
284
+ tableName: "invocations";
285
+ dataType: "string";
286
+ columnType: "PgText";
287
+ data: string;
288
+ driverParam: string;
289
+ notNull: false;
290
+ hasDefault: false;
291
+ isPrimaryKey: false;
292
+ isAutoincrement: false;
293
+ hasRuntimeDefault: false;
294
+ enumValues: [string, ...string[]];
295
+ baseColumn: never;
296
+ identity: undefined;
297
+ generated: undefined;
298
+ }, {}, {}>;
299
+ status: import("drizzle-orm/pg-core").PgColumn<{
300
+ name: "status";
301
+ tableName: "invocations";
302
+ dataType: "string";
303
+ columnType: "PgEnumColumn";
304
+ data: InvocationStatus;
305
+ driverParam: string;
306
+ notNull: true;
307
+ hasDefault: true;
308
+ isPrimaryKey: false;
309
+ isAutoincrement: false;
310
+ hasRuntimeDefault: false;
311
+ enumValues: ["pending", "running", "awaiting_approval", "succeeded", "failed", "cancelled"];
312
+ baseColumn: never;
313
+ identity: undefined;
314
+ generated: undefined;
315
+ }, {}, {
316
+ $type: InvocationStatus;
317
+ }>;
318
+ attemptCount: import("drizzle-orm/pg-core").PgColumn<{
319
+ name: "attempt_count";
320
+ tableName: "invocations";
321
+ dataType: "number";
322
+ columnType: "PgInteger";
323
+ data: number;
324
+ driverParam: string | number;
325
+ notNull: true;
326
+ hasDefault: true;
327
+ isPrimaryKey: false;
328
+ isAutoincrement: false;
329
+ hasRuntimeDefault: false;
330
+ enumValues: undefined;
331
+ baseColumn: never;
332
+ identity: undefined;
333
+ generated: undefined;
334
+ }, {}, {}>;
335
+ maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
336
+ name: "max_attempts";
337
+ tableName: "invocations";
338
+ dataType: "number";
339
+ columnType: "PgInteger";
340
+ data: number;
341
+ driverParam: string | number;
342
+ notNull: true;
343
+ hasDefault: true;
344
+ isPrimaryKey: false;
345
+ isAutoincrement: false;
346
+ hasRuntimeDefault: false;
347
+ enumValues: undefined;
348
+ baseColumn: never;
349
+ identity: undefined;
350
+ generated: undefined;
351
+ }, {}, {}>;
352
+ nextAttemptAt: import("drizzle-orm/pg-core").PgColumn<{
353
+ name: "next_attempt_at";
354
+ tableName: "invocations";
355
+ dataType: "date";
356
+ columnType: "PgTimestamp";
357
+ data: Date;
358
+ driverParam: string;
359
+ notNull: true;
360
+ hasDefault: true;
361
+ isPrimaryKey: false;
362
+ isAutoincrement: false;
363
+ hasRuntimeDefault: false;
364
+ enumValues: undefined;
365
+ baseColumn: never;
366
+ identity: undefined;
367
+ generated: undefined;
368
+ }, {}, {}>;
369
+ claimedAt: import("drizzle-orm/pg-core").PgColumn<{
370
+ name: "claimed_at";
371
+ tableName: "invocations";
372
+ dataType: "date";
373
+ columnType: "PgTimestamp";
374
+ data: Date;
375
+ driverParam: string;
376
+ notNull: false;
377
+ hasDefault: false;
378
+ isPrimaryKey: false;
379
+ isAutoincrement: false;
380
+ hasRuntimeDefault: false;
381
+ enumValues: undefined;
382
+ baseColumn: never;
383
+ identity: undefined;
384
+ generated: undefined;
385
+ }, {}, {}>;
386
+ claimedBy: import("drizzle-orm/pg-core").PgColumn<{
387
+ name: "claimed_by";
388
+ tableName: "invocations";
389
+ dataType: "string";
390
+ columnType: "PgText";
391
+ data: string;
392
+ driverParam: string;
393
+ notNull: false;
394
+ hasDefault: false;
395
+ isPrimaryKey: false;
396
+ isAutoincrement: false;
397
+ hasRuntimeDefault: false;
398
+ enumValues: [string, ...string[]];
399
+ baseColumn: never;
400
+ identity: undefined;
401
+ generated: undefined;
402
+ }, {}, {}>;
403
+ leaseHeartbeatAt: import("drizzle-orm/pg-core").PgColumn<{
404
+ name: "lease_heartbeat_at";
405
+ tableName: "invocations";
406
+ dataType: "date";
407
+ columnType: "PgTimestamp";
408
+ data: Date;
409
+ driverParam: string;
410
+ notNull: false;
411
+ hasDefault: false;
412
+ isPrimaryKey: false;
413
+ isAutoincrement: false;
414
+ hasRuntimeDefault: false;
415
+ enumValues: undefined;
416
+ baseColumn: never;
417
+ identity: undefined;
418
+ generated: undefined;
419
+ }, {}, {}>;
420
+ leaseExpiresAt: import("drizzle-orm/pg-core").PgColumn<{
421
+ name: "lease_expires_at";
422
+ tableName: "invocations";
423
+ dataType: "date";
424
+ columnType: "PgTimestamp";
425
+ data: Date;
426
+ driverParam: string;
427
+ notNull: false;
428
+ hasDefault: false;
429
+ isPrimaryKey: false;
430
+ isAutoincrement: false;
431
+ hasRuntimeDefault: false;
432
+ enumValues: undefined;
433
+ baseColumn: never;
434
+ identity: undefined;
435
+ generated: undefined;
436
+ }, {}, {}>;
437
+ activeRunId: import("drizzle-orm/pg-core").PgColumn<{
438
+ name: "active_run_id";
439
+ tableName: "invocations";
440
+ dataType: "string";
441
+ columnType: "PgUUID";
442
+ data: string;
443
+ driverParam: string;
444
+ notNull: false;
445
+ hasDefault: false;
446
+ isPrimaryKey: false;
447
+ isAutoincrement: false;
448
+ hasRuntimeDefault: false;
449
+ enumValues: undefined;
450
+ baseColumn: never;
451
+ identity: undefined;
452
+ generated: undefined;
453
+ }, {}, {}>;
454
+ activeRunRegisteredAt: import("drizzle-orm/pg-core").PgColumn<{
455
+ name: "active_run_registered_at";
456
+ tableName: "invocations";
457
+ dataType: "date";
458
+ columnType: "PgTimestamp";
459
+ data: Date;
460
+ driverParam: string;
461
+ notNull: false;
462
+ hasDefault: false;
463
+ isPrimaryKey: false;
464
+ isAutoincrement: false;
465
+ hasRuntimeDefault: false;
466
+ enumValues: undefined;
467
+ baseColumn: never;
468
+ identity: undefined;
469
+ generated: undefined;
470
+ }, {}, {}>;
471
+ pendingToolCall: import("drizzle-orm/pg-core").PgColumn<{
472
+ name: "pending_tool_call";
473
+ tableName: "invocations";
474
+ dataType: "json";
475
+ columnType: "PgJsonb";
476
+ data: unknown;
477
+ driverParam: unknown;
478
+ notNull: false;
479
+ hasDefault: false;
480
+ isPrimaryKey: false;
481
+ isAutoincrement: false;
482
+ hasRuntimeDefault: false;
483
+ enumValues: undefined;
484
+ baseColumn: never;
485
+ identity: undefined;
486
+ generated: undefined;
487
+ }, {}, {}>;
488
+ startedAt: import("drizzle-orm/pg-core").PgColumn<{
489
+ name: "started_at";
490
+ tableName: "invocations";
491
+ dataType: "date";
492
+ columnType: "PgTimestamp";
493
+ data: Date;
494
+ driverParam: string;
495
+ notNull: false;
496
+ hasDefault: false;
497
+ isPrimaryKey: false;
498
+ isAutoincrement: false;
499
+ hasRuntimeDefault: false;
500
+ enumValues: undefined;
501
+ baseColumn: never;
502
+ identity: undefined;
503
+ generated: undefined;
504
+ }, {}, {}>;
505
+ completedAt: import("drizzle-orm/pg-core").PgColumn<{
506
+ name: "completed_at";
507
+ tableName: "invocations";
508
+ dataType: "date";
509
+ columnType: "PgTimestamp";
510
+ data: Date;
511
+ driverParam: string;
512
+ notNull: false;
513
+ hasDefault: false;
514
+ isPrimaryKey: false;
515
+ isAutoincrement: false;
516
+ hasRuntimeDefault: false;
517
+ enumValues: undefined;
518
+ baseColumn: never;
519
+ identity: undefined;
520
+ generated: undefined;
521
+ }, {}, {}>;
522
+ failedAt: import("drizzle-orm/pg-core").PgColumn<{
523
+ name: "failed_at";
524
+ tableName: "invocations";
525
+ dataType: "date";
526
+ columnType: "PgTimestamp";
527
+ data: Date;
528
+ driverParam: string;
529
+ notNull: false;
530
+ hasDefault: false;
531
+ isPrimaryKey: false;
532
+ isAutoincrement: false;
533
+ hasRuntimeDefault: false;
534
+ enumValues: undefined;
535
+ baseColumn: never;
536
+ identity: undefined;
537
+ generated: undefined;
538
+ }, {}, {}>;
539
+ provider: import("drizzle-orm/pg-core").PgColumn<{
540
+ name: "provider";
541
+ tableName: "invocations";
542
+ dataType: "string";
543
+ columnType: "PgText";
544
+ data: string;
545
+ driverParam: string;
546
+ notNull: false;
547
+ hasDefault: false;
548
+ isPrimaryKey: false;
549
+ isAutoincrement: false;
550
+ hasRuntimeDefault: false;
551
+ enumValues: [string, ...string[]];
552
+ baseColumn: never;
553
+ identity: undefined;
554
+ generated: undefined;
555
+ }, {}, {}>;
556
+ model: import("drizzle-orm/pg-core").PgColumn<{
557
+ name: "model";
558
+ tableName: "invocations";
559
+ dataType: "string";
560
+ columnType: "PgText";
561
+ data: string;
562
+ driverParam: string;
563
+ notNull: false;
564
+ hasDefault: false;
565
+ isPrimaryKey: false;
566
+ isAutoincrement: false;
567
+ hasRuntimeDefault: false;
568
+ enumValues: [string, ...string[]];
569
+ baseColumn: never;
570
+ identity: undefined;
571
+ generated: undefined;
572
+ }, {}, {}>;
573
+ lastErrorCode: import("drizzle-orm/pg-core").PgColumn<{
574
+ name: "last_error_code";
575
+ tableName: "invocations";
576
+ dataType: "string";
577
+ columnType: "PgText";
578
+ data: string;
579
+ driverParam: string;
580
+ notNull: false;
581
+ hasDefault: false;
582
+ isPrimaryKey: false;
583
+ isAutoincrement: false;
584
+ hasRuntimeDefault: false;
585
+ enumValues: [string, ...string[]];
586
+ baseColumn: never;
587
+ identity: undefined;
588
+ generated: undefined;
589
+ }, {}, {}>;
590
+ lastErrorMessage: import("drizzle-orm/pg-core").PgColumn<{
591
+ name: "last_error_message";
592
+ tableName: "invocations";
593
+ dataType: "string";
594
+ columnType: "PgText";
595
+ data: string;
596
+ driverParam: string;
597
+ notNull: false;
598
+ hasDefault: false;
599
+ isPrimaryKey: false;
600
+ isAutoincrement: false;
601
+ hasRuntimeDefault: false;
602
+ enumValues: [string, ...string[]];
603
+ baseColumn: never;
604
+ identity: undefined;
605
+ generated: undefined;
606
+ }, {}, {}>;
607
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
608
+ name: "metadata";
609
+ tableName: "invocations";
610
+ dataType: "json";
611
+ columnType: "PgJsonb";
612
+ data: Record<string, unknown>;
613
+ driverParam: unknown;
614
+ notNull: false;
615
+ hasDefault: false;
616
+ isPrimaryKey: false;
617
+ isAutoincrement: false;
618
+ hasRuntimeDefault: false;
619
+ enumValues: undefined;
620
+ baseColumn: never;
621
+ identity: undefined;
622
+ generated: undefined;
623
+ }, {}, {
624
+ $type: Record<string, unknown>;
625
+ }>;
626
+ };
627
+ dialect: "pg";
628
+ }>;
629
+ declare const toolCallAudits: import("drizzle-orm/pg-core").PgTableWithColumns<{
630
+ name: "tool_call_audits";
631
+ schema: "agent_runtime";
632
+ columns: {
633
+ id: import("drizzle-orm/pg-core").PgColumn<{
634
+ name: "id";
635
+ tableName: "tool_call_audits";
636
+ dataType: "number";
637
+ columnType: "PgBigInt53";
638
+ data: number;
639
+ driverParam: string | number;
640
+ notNull: true;
641
+ hasDefault: true;
642
+ isPrimaryKey: true;
643
+ isAutoincrement: false;
644
+ hasRuntimeDefault: false;
645
+ enumValues: undefined;
646
+ baseColumn: never;
647
+ identity: "always";
648
+ generated: undefined;
649
+ }, {}, {}>;
650
+ invocationId: import("drizzle-orm/pg-core").PgColumn<{
651
+ name: "invocation_id";
652
+ tableName: "tool_call_audits";
653
+ dataType: "number";
654
+ columnType: "PgBigInt53";
655
+ data: number;
656
+ driverParam: string | number;
657
+ notNull: true;
658
+ hasDefault: false;
659
+ isPrimaryKey: false;
660
+ isAutoincrement: false;
661
+ hasRuntimeDefault: false;
662
+ enumValues: undefined;
663
+ baseColumn: never;
664
+ identity: undefined;
665
+ generated: undefined;
666
+ }, {}, {}>;
667
+ scope: import("drizzle-orm/pg-core").PgColumn<{
668
+ name: "scope";
669
+ tableName: "tool_call_audits";
670
+ dataType: "string";
671
+ columnType: "PgText";
672
+ data: string;
673
+ driverParam: string;
674
+ notNull: true;
675
+ hasDefault: false;
676
+ isPrimaryKey: false;
677
+ isAutoincrement: false;
678
+ hasRuntimeDefault: false;
679
+ enumValues: [string, ...string[]];
680
+ baseColumn: never;
681
+ identity: undefined;
682
+ generated: undefined;
683
+ }, {}, {}>;
684
+ runId: import("drizzle-orm/pg-core").PgColumn<{
685
+ name: "run_id";
686
+ tableName: "tool_call_audits";
687
+ dataType: "string";
688
+ columnType: "PgUUID";
689
+ data: string;
690
+ driverParam: string;
691
+ notNull: false;
692
+ hasDefault: false;
693
+ isPrimaryKey: false;
694
+ isAutoincrement: false;
695
+ hasRuntimeDefault: false;
696
+ enumValues: undefined;
697
+ baseColumn: never;
698
+ identity: undefined;
699
+ generated: undefined;
700
+ }, {}, {}>;
701
+ toolName: import("drizzle-orm/pg-core").PgColumn<{
702
+ name: "tool_name";
703
+ tableName: "tool_call_audits";
704
+ dataType: "string";
705
+ columnType: "PgText";
706
+ data: string;
707
+ driverParam: string;
708
+ notNull: true;
709
+ hasDefault: false;
710
+ isPrimaryKey: false;
711
+ isAutoincrement: false;
712
+ hasRuntimeDefault: false;
713
+ enumValues: [string, ...string[]];
714
+ baseColumn: never;
715
+ identity: undefined;
716
+ generated: undefined;
717
+ }, {}, {}>;
718
+ idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
719
+ name: "idempotency_key";
720
+ tableName: "tool_call_audits";
721
+ dataType: "string";
722
+ columnType: "PgText";
723
+ data: string;
724
+ driverParam: string;
725
+ notNull: false;
726
+ hasDefault: false;
727
+ isPrimaryKey: false;
728
+ isAutoincrement: false;
729
+ hasRuntimeDefault: false;
730
+ enumValues: [string, ...string[]];
731
+ baseColumn: never;
732
+ identity: undefined;
733
+ generated: undefined;
734
+ }, {}, {}>;
735
+ status: import("drizzle-orm/pg-core").PgColumn<{
736
+ name: "status";
737
+ tableName: "tool_call_audits";
738
+ dataType: "string";
739
+ columnType: "PgEnumColumn";
740
+ data: "succeeded" | "failed" | "started";
741
+ driverParam: string;
742
+ notNull: true;
743
+ hasDefault: false;
744
+ isPrimaryKey: false;
745
+ isAutoincrement: false;
746
+ hasRuntimeDefault: false;
747
+ enumValues: ["started", "succeeded", "failed"];
748
+ baseColumn: never;
749
+ identity: undefined;
750
+ generated: undefined;
751
+ }, {}, {}>;
752
+ requestedAt: import("drizzle-orm/pg-core").PgColumn<{
753
+ name: "requested_at";
754
+ tableName: "tool_call_audits";
755
+ dataType: "date";
756
+ columnType: "PgTimestamp";
757
+ data: Date;
758
+ driverParam: string;
759
+ notNull: true;
760
+ hasDefault: true;
761
+ isPrimaryKey: false;
762
+ isAutoincrement: false;
763
+ hasRuntimeDefault: false;
764
+ enumValues: undefined;
765
+ baseColumn: never;
766
+ identity: undefined;
767
+ generated: undefined;
768
+ }, {}, {}>;
769
+ completedAt: import("drizzle-orm/pg-core").PgColumn<{
770
+ name: "completed_at";
771
+ tableName: "tool_call_audits";
772
+ dataType: "date";
773
+ columnType: "PgTimestamp";
774
+ data: Date;
775
+ driverParam: string;
776
+ notNull: false;
777
+ hasDefault: false;
778
+ isPrimaryKey: false;
779
+ isAutoincrement: false;
780
+ hasRuntimeDefault: false;
781
+ enumValues: undefined;
782
+ baseColumn: never;
783
+ identity: undefined;
784
+ generated: undefined;
785
+ }, {}, {}>;
786
+ errorCode: import("drizzle-orm/pg-core").PgColumn<{
787
+ name: "error_code";
788
+ tableName: "tool_call_audits";
789
+ dataType: "string";
790
+ columnType: "PgText";
791
+ data: string;
792
+ driverParam: string;
793
+ notNull: false;
794
+ hasDefault: false;
795
+ isPrimaryKey: false;
796
+ isAutoincrement: false;
797
+ hasRuntimeDefault: false;
798
+ enumValues: [string, ...string[]];
799
+ baseColumn: never;
800
+ identity: undefined;
801
+ generated: undefined;
802
+ }, {}, {}>;
803
+ requestSnapshot: import("drizzle-orm/pg-core").PgColumn<{
804
+ name: "request_snapshot";
805
+ tableName: "tool_call_audits";
806
+ dataType: "json";
807
+ columnType: "PgJsonb";
808
+ data: unknown;
809
+ driverParam: unknown;
810
+ notNull: false;
811
+ hasDefault: false;
812
+ isPrimaryKey: false;
813
+ isAutoincrement: false;
814
+ hasRuntimeDefault: false;
815
+ enumValues: undefined;
816
+ baseColumn: never;
817
+ identity: undefined;
818
+ generated: undefined;
819
+ }, {}, {}>;
820
+ metadata: import("drizzle-orm/pg-core").PgColumn<{
821
+ name: "metadata";
822
+ tableName: "tool_call_audits";
823
+ dataType: "json";
824
+ columnType: "PgJsonb";
825
+ data: Record<string, unknown>;
826
+ driverParam: unknown;
827
+ notNull: false;
828
+ hasDefault: false;
829
+ isPrimaryKey: false;
830
+ isAutoincrement: false;
831
+ hasRuntimeDefault: false;
832
+ enumValues: undefined;
833
+ baseColumn: never;
834
+ identity: undefined;
835
+ generated: undefined;
836
+ }, {}, {
837
+ $type: Record<string, unknown>;
838
+ }>;
839
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
840
+ name: "created_at";
841
+ tableName: "tool_call_audits";
842
+ dataType: "date";
843
+ columnType: "PgTimestamp";
844
+ data: Date;
845
+ driverParam: string;
846
+ notNull: true;
847
+ hasDefault: true;
848
+ isPrimaryKey: false;
849
+ isAutoincrement: false;
850
+ hasRuntimeDefault: false;
851
+ enumValues: undefined;
852
+ baseColumn: never;
853
+ identity: undefined;
854
+ generated: undefined;
855
+ }, {}, {}>;
856
+ };
857
+ dialect: "pg";
858
+ }>;
859
+ declare const policyDecisions: import("drizzle-orm/pg-core").PgTableWithColumns<{
860
+ name: "policy_decisions";
861
+ schema: "agent_runtime";
862
+ columns: {
863
+ id: import("drizzle-orm/pg-core").PgColumn<{
864
+ name: "id";
865
+ tableName: "policy_decisions";
866
+ dataType: "number";
867
+ columnType: "PgBigInt53";
868
+ data: number;
869
+ driverParam: string | number;
870
+ notNull: true;
871
+ hasDefault: true;
872
+ isPrimaryKey: true;
873
+ isAutoincrement: false;
874
+ hasRuntimeDefault: false;
875
+ enumValues: undefined;
876
+ baseColumn: never;
877
+ identity: "always";
878
+ generated: undefined;
879
+ }, {}, {}>;
880
+ scope: import("drizzle-orm/pg-core").PgColumn<{
881
+ name: "scope";
882
+ tableName: "policy_decisions";
883
+ dataType: "string";
884
+ columnType: "PgText";
885
+ data: string;
886
+ driverParam: string;
887
+ notNull: true;
888
+ hasDefault: false;
889
+ isPrimaryKey: false;
890
+ isAutoincrement: false;
891
+ hasRuntimeDefault: false;
892
+ enumValues: [string, ...string[]];
893
+ baseColumn: never;
894
+ identity: undefined;
895
+ generated: undefined;
896
+ }, {}, {}>;
897
+ invocationId: import("drizzle-orm/pg-core").PgColumn<{
898
+ name: "invocation_id";
899
+ tableName: "policy_decisions";
900
+ dataType: "number";
901
+ columnType: "PgBigInt53";
902
+ data: number;
903
+ driverParam: string | number;
904
+ notNull: true;
905
+ hasDefault: false;
906
+ isPrimaryKey: false;
907
+ isAutoincrement: false;
908
+ hasRuntimeDefault: false;
909
+ enumValues: undefined;
910
+ baseColumn: never;
911
+ identity: undefined;
912
+ generated: undefined;
913
+ }, {}, {}>;
914
+ runId: import("drizzle-orm/pg-core").PgColumn<{
915
+ name: "run_id";
916
+ tableName: "policy_decisions";
917
+ dataType: "string";
918
+ columnType: "PgUUID";
919
+ data: string;
920
+ driverParam: string;
921
+ notNull: true;
922
+ hasDefault: false;
923
+ isPrimaryKey: false;
924
+ isAutoincrement: false;
925
+ hasRuntimeDefault: false;
926
+ enumValues: undefined;
927
+ baseColumn: never;
928
+ identity: undefined;
929
+ generated: undefined;
930
+ }, {}, {}>;
931
+ toolName: import("drizzle-orm/pg-core").PgColumn<{
932
+ name: "tool_name";
933
+ tableName: "policy_decisions";
934
+ dataType: "string";
935
+ columnType: "PgText";
936
+ data: string;
937
+ driverParam: string;
938
+ notNull: false;
939
+ hasDefault: false;
940
+ isPrimaryKey: false;
941
+ isAutoincrement: false;
942
+ hasRuntimeDefault: false;
943
+ enumValues: [string, ...string[]];
944
+ baseColumn: never;
945
+ identity: undefined;
946
+ generated: undefined;
947
+ }, {}, {}>;
948
+ rule: import("drizzle-orm/pg-core").PgColumn<{
949
+ name: "rule";
950
+ tableName: "policy_decisions";
951
+ dataType: "string";
952
+ columnType: "PgText";
953
+ data: PolicyRule;
954
+ driverParam: string;
955
+ notNull: true;
956
+ hasDefault: false;
957
+ isPrimaryKey: false;
958
+ isAutoincrement: false;
959
+ hasRuntimeDefault: false;
960
+ enumValues: [string, ...string[]];
961
+ baseColumn: never;
962
+ identity: undefined;
963
+ generated: undefined;
964
+ }, {}, {
965
+ $type: PolicyRule;
966
+ }>;
967
+ decision: import("drizzle-orm/pg-core").PgColumn<{
968
+ name: "decision";
969
+ tableName: "policy_decisions";
970
+ dataType: "string";
971
+ columnType: "PgText";
972
+ data: PolicyDecisionKind;
973
+ driverParam: string;
974
+ notNull: true;
975
+ hasDefault: false;
976
+ isPrimaryKey: false;
977
+ isAutoincrement: false;
978
+ hasRuntimeDefault: false;
979
+ enumValues: [string, ...string[]];
980
+ baseColumn: never;
981
+ identity: undefined;
982
+ generated: undefined;
983
+ }, {}, {
984
+ $type: PolicyDecisionKind;
985
+ }>;
986
+ detail: import("drizzle-orm/pg-core").PgColumn<{
987
+ name: "detail";
988
+ tableName: "policy_decisions";
989
+ dataType: "json";
990
+ columnType: "PgJsonb";
991
+ data: Record<string, unknown>;
992
+ driverParam: unknown;
993
+ notNull: false;
994
+ hasDefault: false;
995
+ isPrimaryKey: false;
996
+ isAutoincrement: false;
997
+ hasRuntimeDefault: false;
998
+ enumValues: undefined;
999
+ baseColumn: never;
1000
+ identity: undefined;
1001
+ generated: undefined;
1002
+ }, {}, {
1003
+ $type: Record<string, unknown>;
1004
+ }>;
1005
+ createdAt: import("drizzle-orm/pg-core").PgColumn<{
1006
+ name: "created_at";
1007
+ tableName: "policy_decisions";
1008
+ dataType: "date";
1009
+ columnType: "PgTimestamp";
1010
+ data: Date;
1011
+ driverParam: string;
1012
+ notNull: true;
1013
+ hasDefault: true;
1014
+ isPrimaryKey: false;
1015
+ isAutoincrement: false;
1016
+ hasRuntimeDefault: false;
1017
+ enumValues: undefined;
1018
+ baseColumn: never;
1019
+ identity: undefined;
1020
+ generated: undefined;
1021
+ }, {}, {}>;
1022
+ };
1023
+ dialect: "pg";
1024
+ }>;
1025
+ declare const workerLeases: import("drizzle-orm/pg-core").PgTableWithColumns<{
1026
+ name: "worker_leases";
1027
+ schema: "agent_runtime";
1028
+ columns: {
1029
+ name: import("drizzle-orm/pg-core").PgColumn<{
1030
+ name: "name";
1031
+ tableName: "worker_leases";
1032
+ dataType: "string";
1033
+ columnType: "PgText";
1034
+ data: string;
1035
+ driverParam: string;
1036
+ notNull: true;
1037
+ hasDefault: false;
1038
+ isPrimaryKey: true;
1039
+ isAutoincrement: false;
1040
+ hasRuntimeDefault: false;
1041
+ enumValues: [string, ...string[]];
1042
+ baseColumn: never;
1043
+ identity: undefined;
1044
+ generated: undefined;
1045
+ }, {}, {}>;
1046
+ holderId: import("drizzle-orm/pg-core").PgColumn<{
1047
+ name: "holder_id";
1048
+ tableName: "worker_leases";
1049
+ dataType: "string";
1050
+ columnType: "PgText";
1051
+ data: string;
1052
+ driverParam: string;
1053
+ notNull: true;
1054
+ hasDefault: false;
1055
+ isPrimaryKey: false;
1056
+ isAutoincrement: false;
1057
+ hasRuntimeDefault: false;
1058
+ enumValues: [string, ...string[]];
1059
+ baseColumn: never;
1060
+ identity: undefined;
1061
+ generated: undefined;
1062
+ }, {}, {}>;
1063
+ acquiredAt: import("drizzle-orm/pg-core").PgColumn<{
1064
+ name: "acquired_at";
1065
+ tableName: "worker_leases";
1066
+ dataType: "date";
1067
+ columnType: "PgTimestamp";
1068
+ data: Date;
1069
+ driverParam: string;
1070
+ notNull: true;
1071
+ hasDefault: true;
1072
+ isPrimaryKey: false;
1073
+ isAutoincrement: false;
1074
+ hasRuntimeDefault: false;
1075
+ enumValues: undefined;
1076
+ baseColumn: never;
1077
+ identity: undefined;
1078
+ generated: undefined;
1079
+ }, {}, {}>;
1080
+ heartbeatAt: import("drizzle-orm/pg-core").PgColumn<{
1081
+ name: "heartbeat_at";
1082
+ tableName: "worker_leases";
1083
+ dataType: "date";
1084
+ columnType: "PgTimestamp";
1085
+ data: Date;
1086
+ driverParam: string;
1087
+ notNull: true;
1088
+ hasDefault: true;
1089
+ isPrimaryKey: false;
1090
+ isAutoincrement: false;
1091
+ hasRuntimeDefault: false;
1092
+ enumValues: undefined;
1093
+ baseColumn: never;
1094
+ identity: undefined;
1095
+ generated: undefined;
1096
+ }, {}, {}>;
1097
+ expiresAt: import("drizzle-orm/pg-core").PgColumn<{
1098
+ name: "expires_at";
1099
+ tableName: "worker_leases";
1100
+ dataType: "date";
1101
+ columnType: "PgTimestamp";
1102
+ data: Date;
1103
+ driverParam: string;
1104
+ notNull: true;
1105
+ hasDefault: false;
1106
+ isPrimaryKey: false;
1107
+ isAutoincrement: false;
1108
+ hasRuntimeDefault: false;
1109
+ enumValues: undefined;
1110
+ baseColumn: never;
1111
+ identity: undefined;
1112
+ generated: undefined;
1113
+ }, {}, {}>;
1114
+ };
1115
+ dialect: "pg";
1116
+ }>;
1117
+ type InvocationRow = typeof invocations.$inferSelect;
1118
+ type PolicyDecisionRow = typeof policyDecisions.$inferSelect;
1119
+ type Database = NodePgDatabase<typeof schema_d_exports>;
1120
+ interface DatabaseHandle {
1121
+ readonly kind: 'runwarden/database';
1122
+ readonly db: Database;
1123
+ readonly pool: Pool;
1124
+ close(): Promise<void>;
1125
+ }
1126
+ export declare function createDb(connectionString: string): DatabaseHandle;
1127
+ interface ApprovalResolutionOptions {
1128
+ resolvedBy?: string;
1129
+ note?: string;
1130
+ }
1131
+ interface OpenAiCompatibleModelConfig {
1132
+ baseUrl: string;
1133
+ apiKey: string;
1134
+ model: string;
1135
+ timeoutMs?: number;
1136
+ }
1137
+ export declare function openAiCompatible(config: OpenAiCompatibleModelConfig, fetchImpl?: typeof fetch): LanguageModel;
1138
+ declare const RUNTIME_INTERNALS: unique symbol;
1139
+ interface RuntimeInternals {
1140
+ onPolicyDecision(listener: (decision: PolicyDecision) => void): () => void;
1141
+ onToolCallAudit?: (listener: (event: ToolCallAuditEvent) => Promise<void>) => () => void;
1142
+ }
1143
+ interface DefineRuntimeOptions {
1144
+ db?: DatabaseHandle;
1145
+ model?: LanguageModel;
1146
+ provider?: OpenAiCompatibleModelConfig;
1147
+ tools?: ToolDefinition[];
1148
+ mcpServers?: McpServerConfig[];
1149
+ mcpClient?: McpToolClient;
1150
+ loadSystemPrompt?: SystemPromptLoader;
1151
+ loadHistory?: HistoryLoader;
1152
+ policies?: RuntimePolicies;
1153
+ onMetrics?: (metrics: RuntimeMetrics) => void;
1154
+ onPolicyDecision?: (decision: PolicyDecision) => void;
1155
+ onToolCallAudit?: ToolCallAuditSink;
1156
+ }
1157
+ interface InvokeOptions {
1158
+ waitTimeoutMs?: number;
1159
+ pollIntervalMs?: number;
1160
+ }
1161
+ type ApprovalActionOptions = ApprovalResolutionOptions;
1162
+ interface Runtime {
1163
+ invoke(input: InvocationInput, opts?: InvokeOptions): Promise<InvocationResult>;
1164
+ enqueue(input: InvocationInput): Promise<{
1165
+ invocationId: string;
1166
+ }>;
1167
+ getInvocation(id: string): Promise<InvocationRecord | undefined>;
1168
+ waitForInvocation(id: string, opts?: InvokeOptions): Promise<InvocationResult>;
1169
+ listPendingApprovals(scope?: string): Promise<InvocationRecord[]>;
1170
+ approveInvocation(id: string, opts?: ApprovalActionOptions): Promise<InvocationRecord>;
1171
+ rejectInvocation(id: string, opts?: ApprovalActionOptions): Promise<InvocationRecord>;
1172
+ readonly engine: AgentRuntime;
1173
+ readonly [RUNTIME_INTERNALS]?: RuntimeInternals;
1174
+ }
1175
+ export declare function defineRuntime(options: DefineRuntimeOptions): Runtime;
1176
+ interface InitResult {
1177
+ applied: string[];
1178
+ alreadyApplied: string[];
1179
+ }
1180
+ interface InitOptions {
1181
+ migrationsDir?: string;
1182
+ }
1183
+ export declare function initDb(handle: DatabaseHandle, options?: InitOptions): Promise<InitResult>;
1184
+ interface RunWorkerOptions {
1185
+ runtime: {
1186
+ engine: AgentRuntime;
1187
+ readonly [RUNTIME_INTERNALS]?: RuntimeInternals;
1188
+ };
1189
+ db: DatabaseHandle;
1190
+ workerId?: string;
1191
+ leaseTimeoutMs?: number;
1192
+ heartbeatIntervalMs?: number;
1193
+ retryDelayMs?: number;
1194
+ pollIdleMs?: number;
1195
+ pollActiveMs?: number;
1196
+ onSucceeded?: (invocation: InvocationRecord, result: InvocationResult) => Promise<void>;
1197
+ onFailed?: (invocation: InvocationRecord, error: AgentRuntimeError) => Promise<void>;
1198
+ onAwaitingApproval?: (invocation: InvocationRecord, pendingToolCall: PendingToolCall) => Promise<void>;
1199
+ }
1200
+ interface WorkerHandle {
1201
+ stop(): Promise<void>;
1202
+ }
1203
+ export declare function runWorker(options: RunWorkerOptions): WorkerHandle;
1204
+ interface NativeMcpClientConfig {
1205
+ endpoint: string;
1206
+ headers?: Record<string, string>;
1207
+ timeoutMs?: number;
1208
+ maxResultBytes?: number;
1209
+ }
1210
+ export declare class NativeMcpClient implements McpToolClient {
1211
+ private readonly endpoint;
1212
+ private readonly headers;
1213
+ private readonly timeoutMs;
1214
+ private readonly maxResultBytes;
1215
+ constructor(config: NativeMcpClientConfig);
1216
+ open(input: {
1217
+ runId: string;
1218
+ timeoutMs: number;
1219
+ }): Promise<McpToolSession>;
1220
+ }
1221
+ type FakeAgentRuntimeResultFactory = (input: RuntimeInvocationInput, invocationIndex: number) => InvocationResult;
1222
+ export declare class FakeAgentRuntime implements AgentRuntime {
1223
+ private readonly result?;
1224
+ private readonly invocations;
1225
+ constructor(result?: (InvocationResult | FakeAgentRuntimeResultFactory) | undefined);
1226
+ getInvocationHistory(): readonly RuntimeInvocationInput[];
1227
+ invoke(input: RuntimeInvocationInput): Promise<InvocationResult>;
1228
+ }
1229
+ export declare const RUNTIME_NAME = "runwarden";
1230
+ export declare const RUN_ID_HEADER = "X-Runwarden-Run-Id";
1231
+ export declare const ERROR_CATEGORY_META_KEY = "runwarden/error-category";
1232
+ export type { AgentRuntime, AgentRuntimeErrorKind, ApprovalActionOptions, DatabaseHandle, DefineRuntimeOptions, HistoryLoader, InitOptions, InitResult, InvocationInput, InvocationRecord, InvocationResult, InvocationStatus, InvokeOptions, McpServerConfig, McpToolClient, McpToolSession, NativeMcpClientConfig, NeutralMessage, OpenAiCompatibleModelConfig, PendingToolCall, PolicyDecision, PolicyDecisionKind, PolicyRule, RunWorkerOptions, Runtime, RuntimeInvocationInput, RuntimeMetrics, RuntimePolicies, SystemPromptLoader, ToolCallAuditEvent, ToolCallAuditSink, ToolDefinition, WorkerHandle };