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