@tpsdev-ai/agent 0.5.4 → 0.6.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.
- package/dist/bin.js +47 -2
- package/dist/bin.js.map +1 -1
- package/dist/config.d.ts +2 -1
- package/dist/config.d.ts.map +1 -1
- package/dist/config.js +8 -0
- package/dist/config.js.map +1 -1
- package/dist/index.d.ts +4 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +4 -0
- package/dist/index.js.map +1 -1
- package/dist/io/flair.d.ts +43 -0
- package/dist/io/flair.d.ts.map +1 -0
- package/dist/io/flair.js +143 -0
- package/dist/io/flair.js.map +1 -0
- package/dist/io/mail.d.ts +24 -2
- package/dist/io/mail.d.ts.map +1 -1
- package/dist/io/mail.js +168 -15
- package/dist/io/mail.js.map +1 -1
- package/dist/lib/signEnvelope.d.ts +67 -0
- package/dist/lib/signEnvelope.d.ts.map +1 -0
- package/dist/lib/signEnvelope.js +244 -0
- package/dist/lib/signEnvelope.js.map +1 -0
- package/dist/llm/provider.d.ts +19 -1
- package/dist/llm/provider.d.ts.map +1 -1
- package/dist/llm/provider.js +362 -18
- package/dist/llm/provider.js.map +1 -1
- package/dist/runtime/agent.d.ts +2 -0
- package/dist/runtime/agent.d.ts.map +1 -1
- package/dist/runtime/agent.js +50 -3
- package/dist/runtime/agent.js.map +1 -1
- package/dist/runtime/event-loop.d.ts +36 -5
- package/dist/runtime/event-loop.d.ts.map +1 -1
- package/dist/runtime/event-loop.js +235 -32
- package/dist/runtime/event-loop.js.map +1 -1
- package/dist/runtime/types.d.ts +16 -1
- package/dist/runtime/types.d.ts.map +1 -1
- package/dist/telemetry/events.d.ts +57 -0
- package/dist/telemetry/events.d.ts.map +1 -0
- package/dist/telemetry/events.js +37 -0
- package/dist/telemetry/events.js.map +1 -0
- package/dist/tools/edit.d.ts.map +1 -1
- package/dist/tools/edit.js +94 -16
- package/dist/tools/edit.js.map +1 -1
- package/package.json +10 -2
- package/src/bin.ts +56 -3
- package/src/config.ts +10 -1
- package/src/index.ts +8 -0
- package/src/io/flair.ts +183 -0
- package/src/io/mail.ts +184 -19
- package/src/lib/signEnvelope.ts +332 -0
- package/src/llm/provider.ts +391 -17
- package/src/runtime/agent.ts +55 -3
- package/src/runtime/event-loop.ts +233 -15
- package/src/runtime/types.ts +20 -1
- package/src/telemetry/events.ts +101 -0
- package/src/tools/edit.ts +108 -17
- package/test/bin-launch-id.test.ts +104 -0
- package/test/core-loop.test.ts +240 -0
- package/test/events.test.ts +33 -0
- package/test/flair-context.test.ts +102 -0
- package/test/governance.test.ts +103 -2
- package/test/io.test.ts +8 -8
- package/test/provider.test.ts +43 -0
package/src/llm/provider.ts
CHANGED
|
@@ -1,3 +1,7 @@
|
|
|
1
|
+
import crypto from "node:crypto";
|
|
2
|
+
import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
|
|
3
|
+
import { homedir } from "node:os";
|
|
4
|
+
import { join } from "node:path";
|
|
1
5
|
import type {
|
|
2
6
|
LLMConfig,
|
|
3
7
|
CompletionRequest,
|
|
@@ -6,28 +10,214 @@ import type {
|
|
|
6
10
|
ToolSpec,
|
|
7
11
|
LLMMessage,
|
|
8
12
|
} from "../runtime/types.js";
|
|
13
|
+
import type { EventLogger } from "../telemetry/events.js";
|
|
14
|
+
import { sanitizeError } from "../telemetry/events.js";
|
|
9
15
|
|
|
10
16
|
type ProviderKind = LLMConfig["provider"];
|
|
11
17
|
|
|
18
|
+
interface OAuthCredentials {
|
|
19
|
+
provider: string;
|
|
20
|
+
refreshToken: string;
|
|
21
|
+
accessToken: string;
|
|
22
|
+
expiresAt: number;
|
|
23
|
+
clientId: string;
|
|
24
|
+
scopes: string;
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
const AUTH_DIR = join(process.env.HOME || homedir(), ".tps", "auth");
|
|
28
|
+
const ANTHROPIC_TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
|
|
29
|
+
const GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
|
|
30
|
+
|
|
31
|
+
function oauthPath(provider: string): string {
|
|
32
|
+
return join(AUTH_DIR, `${provider}.json`);
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
function loadOAuth(provider: string): OAuthCredentials | null {
|
|
36
|
+
const p = oauthPath(provider);
|
|
37
|
+
if (!existsSync(p)) return null;
|
|
38
|
+
return JSON.parse(readFileSync(p, "utf-8")) as OAuthCredentials;
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
function saveOAuth(provider: string, creds: OAuthCredentials): void {
|
|
42
|
+
mkdirSync(AUTH_DIR, { recursive: true, mode: 0o700 });
|
|
43
|
+
writeFileSync(oauthPath(provider), JSON.stringify(creds, null, 2), { mode: 0o600 });
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
export async function refreshAnthropicOAuthToken(creds: OAuthCredentials): Promise<OAuthCredentials> {
|
|
47
|
+
const res = await fetch(ANTHROPIC_TOKEN_URL, {
|
|
48
|
+
method: "POST",
|
|
49
|
+
headers: {
|
|
50
|
+
"Content-Type": "application/json",
|
|
51
|
+
"User-Agent": "claude-code/1.0",
|
|
52
|
+
},
|
|
53
|
+
body: JSON.stringify({
|
|
54
|
+
grant_type: "refresh_token",
|
|
55
|
+
client_id: creds.clientId,
|
|
56
|
+
refresh_token: creds.refreshToken,
|
|
57
|
+
}),
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
if (!res.ok) {
|
|
61
|
+
throw new Error(`Anthropic token refresh failed: ${res.status} ${await res.text()}`);
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
const token = (await res.json()) as any;
|
|
65
|
+
const refreshed: OAuthCredentials = {
|
|
66
|
+
...creds,
|
|
67
|
+
accessToken: token.access_token,
|
|
68
|
+
refreshToken: token.refresh_token || creds.refreshToken,
|
|
69
|
+
expiresAt: Date.now() + Number(token.expires_in || 0) * 1000,
|
|
70
|
+
};
|
|
71
|
+
|
|
72
|
+
// Sync back to Claude Code's credential file to prevent split-brain (S46-C)
|
|
73
|
+
syncToClaudeCode(refreshed);
|
|
74
|
+
|
|
75
|
+
return refreshed;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
/**
|
|
79
|
+
* Keep Claude Code's credentials in sync after TPS refreshes the token.
|
|
80
|
+
*/
|
|
81
|
+
function syncToClaudeCode(creds: OAuthCredentials): void {
|
|
82
|
+
const credPath = join(process.env.HOME || homedir(), ".claude", ".credentials.json");
|
|
83
|
+
if (!existsSync(credPath)) return;
|
|
84
|
+
try {
|
|
85
|
+
const data = JSON.parse(readFileSync(credPath, "utf-8"));
|
|
86
|
+
if (!data.claudeAiOauth) return;
|
|
87
|
+
data.claudeAiOauth.accessToken = creds.accessToken;
|
|
88
|
+
data.claudeAiOauth.refreshToken = creds.refreshToken;
|
|
89
|
+
data.claudeAiOauth.expiresAt = creds.expiresAt;
|
|
90
|
+
writeFileSync(credPath, JSON.stringify(data, null, 2), { mode: 0o600 });
|
|
91
|
+
} catch {
|
|
92
|
+
// Best-effort sync
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
|
|
97
|
+
export async function refreshGoogleOAuthToken(creds: OAuthCredentials): Promise<OAuthCredentials> {
|
|
98
|
+
if (!creds.clientId) {
|
|
99
|
+
throw new Error("Google OAuth refresh requires clientId. Run: tps auth login google");
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
const body = new URLSearchParams({
|
|
103
|
+
grant_type: "refresh_token",
|
|
104
|
+
client_id: creds.clientId,
|
|
105
|
+
refresh_token: creds.refreshToken,
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
const res = await fetch(GOOGLE_TOKEN_URL, {
|
|
109
|
+
method: "POST",
|
|
110
|
+
headers: { "Content-Type": "application/x-www-form-urlencoded" },
|
|
111
|
+
body,
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
if (!res.ok) {
|
|
115
|
+
throw new Error(`Google token refresh failed: ${res.status} ${await res.text()}`);
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
const token = (await res.json()) as any;
|
|
119
|
+
const refreshed: OAuthCredentials = {
|
|
120
|
+
...creds,
|
|
121
|
+
accessToken: token.access_token,
|
|
122
|
+
refreshToken: token.refresh_token || creds.refreshToken,
|
|
123
|
+
expiresAt: Date.now() + Number(token.expires_in || 0) * 1000,
|
|
124
|
+
scopes: token.scope || creds.scopes,
|
|
125
|
+
};
|
|
126
|
+
|
|
127
|
+
syncToGeminiCli(refreshed);
|
|
128
|
+
return refreshed;
|
|
129
|
+
}
|
|
130
|
+
|
|
131
|
+
function syncToGeminiCli(creds: OAuthCredentials): void {
|
|
132
|
+
const home = process.env.HOME || homedir();
|
|
133
|
+
const xdg = process.env.XDG_CONFIG_HOME || join(home, ".config");
|
|
134
|
+
const candidates = [
|
|
135
|
+
join(home, ".gemini", "oauth_creds.json"),
|
|
136
|
+
join(xdg, "gemini", "oauth_creds.json"),
|
|
137
|
+
];
|
|
138
|
+
|
|
139
|
+
for (const credPath of candidates) {
|
|
140
|
+
if (!existsSync(credPath)) continue;
|
|
141
|
+
try {
|
|
142
|
+
const data = JSON.parse(readFileSync(credPath, "utf-8"));
|
|
143
|
+
data.access_token = creds.accessToken;
|
|
144
|
+
data.refresh_token = creds.refreshToken;
|
|
145
|
+
data.expiry_date = creds.expiresAt;
|
|
146
|
+
if (creds.scopes) data.scope = creds.scopes;
|
|
147
|
+
if (creds.clientId) data.client_id = creds.clientId;
|
|
148
|
+
writeFileSync(credPath, JSON.stringify(data, null, 2), { mode: 0o600 });
|
|
149
|
+
return;
|
|
150
|
+
} catch {
|
|
151
|
+
// Best-effort sync
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
}
|
|
155
|
+
|
|
12
156
|
/**
|
|
13
157
|
* Routes completion requests to the configured provider and normalizes
|
|
14
158
|
* tool-call responses into a common shape.
|
|
15
159
|
*/
|
|
16
160
|
export class ProviderManager {
|
|
17
|
-
constructor(
|
|
161
|
+
constructor(
|
|
162
|
+
private readonly config: LLMConfig,
|
|
163
|
+
private readonly events?: EventLogger,
|
|
164
|
+
private readonly agentId = "unknown",
|
|
165
|
+
) {}
|
|
18
166
|
|
|
19
167
|
async complete(request: CompletionRequest): Promise<CompletionResponse> {
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
168
|
+
const started = Date.now();
|
|
169
|
+
const provider = this.config.provider;
|
|
170
|
+
const model = this.config.model;
|
|
171
|
+
try {
|
|
172
|
+
let out: CompletionResponse;
|
|
173
|
+
|
|
174
|
+
// Route through proxy when configured (sandbox mode)
|
|
175
|
+
if (this.config.proxyUrl) {
|
|
176
|
+
out = await this.completeViaProxy(request);
|
|
177
|
+
} else
|
|
178
|
+
switch (provider) {
|
|
179
|
+
case "anthropic":
|
|
180
|
+
out = await this.completeAnthropic(request);
|
|
181
|
+
break;
|
|
182
|
+
case "google":
|
|
183
|
+
out = await this.completeGoogle(request);
|
|
184
|
+
break;
|
|
185
|
+
case "openai":
|
|
186
|
+
out = await this.completeOpenAI(request);
|
|
187
|
+
break;
|
|
188
|
+
case "ollama":
|
|
189
|
+
out = await this.completeOllama(request);
|
|
190
|
+
break;
|
|
191
|
+
default:
|
|
192
|
+
throw new Error(`Unsupported provider: ${provider}`);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
this.events?.emit({
|
|
196
|
+
type: "llm.request",
|
|
197
|
+
agent: this.agentId,
|
|
198
|
+
provider,
|
|
199
|
+
model,
|
|
200
|
+
inputTokens: out.inputTokens ?? 0,
|
|
201
|
+
outputTokens: out.outputTokens ?? 0,
|
|
202
|
+
cacheReadTokens: out.cacheReadTokens,
|
|
203
|
+
cacheWriteTokens: out.cacheWriteTokens,
|
|
204
|
+
durationMs: Date.now() - started,
|
|
205
|
+
status: "ok",
|
|
206
|
+
});
|
|
207
|
+
return out;
|
|
208
|
+
} catch (err) {
|
|
209
|
+
this.events?.emit({
|
|
210
|
+
type: "llm.request",
|
|
211
|
+
agent: this.agentId,
|
|
212
|
+
provider,
|
|
213
|
+
model,
|
|
214
|
+
inputTokens: 0,
|
|
215
|
+
outputTokens: 0,
|
|
216
|
+
durationMs: Date.now() - started,
|
|
217
|
+
status: "error",
|
|
218
|
+
error: sanitizeError(err),
|
|
219
|
+
});
|
|
220
|
+
throw err;
|
|
31
221
|
}
|
|
32
222
|
}
|
|
33
223
|
|
|
@@ -161,8 +351,173 @@ export class ProviderManager {
|
|
|
161
351
|
});
|
|
162
352
|
}
|
|
163
353
|
|
|
354
|
+
|
|
355
|
+
/**
|
|
356
|
+
* Route LLM request through the TPS localhost proxy.
|
|
357
|
+
* The proxy holds API keys; agent authenticates with Ed25519.
|
|
358
|
+
*/
|
|
359
|
+
private async completeViaProxy(request: CompletionRequest): Promise<CompletionResponse> {
|
|
360
|
+
const proxyUrl = this.config.proxyUrl!;
|
|
361
|
+
const provider = this.config.provider;
|
|
362
|
+
const model = this.config.model;
|
|
363
|
+
|
|
364
|
+
// Build provider-specific request body
|
|
365
|
+
let body: Record<string, unknown>;
|
|
366
|
+
let providerPath: string;
|
|
367
|
+
|
|
368
|
+
switch (provider) {
|
|
369
|
+
case "claude-oauth":
|
|
370
|
+
case "anthropic": {
|
|
371
|
+
providerPath = provider === "claude-oauth" ? "/proxy/claude-oauth/v1/messages" : "/proxy/anthropic/v1/messages";
|
|
372
|
+
const anthropicMessages = request.messages.map((m) => {
|
|
373
|
+
if (m._raw) return m._raw;
|
|
374
|
+
if (m.role === "tool") {
|
|
375
|
+
return {
|
|
376
|
+
role: "user",
|
|
377
|
+
content: [{
|
|
378
|
+
type: "tool_result",
|
|
379
|
+
tool_use_id: m.tool_call_id,
|
|
380
|
+
content: m.content ?? "",
|
|
381
|
+
}],
|
|
382
|
+
};
|
|
383
|
+
}
|
|
384
|
+
return { role: m.role, content: m.content ?? "" };
|
|
385
|
+
});
|
|
386
|
+
body = {
|
|
387
|
+
model,
|
|
388
|
+
max_tokens: request.maxTokens ?? 4096,
|
|
389
|
+
system: request.systemPrompt,
|
|
390
|
+
messages: anthropicMessages,
|
|
391
|
+
};
|
|
392
|
+
if (request.tools?.length) {
|
|
393
|
+
body.tools = request.tools.map((t) => ({
|
|
394
|
+
name: t.name,
|
|
395
|
+
description: t.description,
|
|
396
|
+
input_schema: t.input_schema,
|
|
397
|
+
}));
|
|
398
|
+
body.tool_choice = { type: "auto" };
|
|
399
|
+
}
|
|
400
|
+
break;
|
|
401
|
+
}
|
|
402
|
+
case "openai":
|
|
403
|
+
case "openai-oauth":
|
|
404
|
+
providerPath = provider === "openai-oauth"
|
|
405
|
+
? "/proxy/openai-oauth/v1/chat/completions"
|
|
406
|
+
: "/proxy/openai/v1/chat/completions";
|
|
407
|
+
body = {
|
|
408
|
+
model,
|
|
409
|
+
max_tokens: request.maxTokens ?? 4096,
|
|
410
|
+
messages: [
|
|
411
|
+
...(request.systemPrompt ? [{ role: "system", content: request.systemPrompt }] : []),
|
|
412
|
+
...request.messages.map((m) => ({ role: m.role, content: m.content })),
|
|
413
|
+
],
|
|
414
|
+
};
|
|
415
|
+
if (request.tools?.length) {
|
|
416
|
+
body.tools = request.tools.map((t) => ({
|
|
417
|
+
type: "function",
|
|
418
|
+
function: { name: t.name, description: t.description, parameters: t.input_schema },
|
|
419
|
+
}));
|
|
420
|
+
}
|
|
421
|
+
break;
|
|
422
|
+
default:
|
|
423
|
+
throw new Error(`Proxy not supported for provider: ${provider}. Use direct mode.`);
|
|
424
|
+
}
|
|
425
|
+
|
|
426
|
+
// Sign with Ed25519
|
|
427
|
+
const ts = Date.now().toString();
|
|
428
|
+
const nonce = crypto.randomUUID();
|
|
429
|
+
const signPayload = `${this.agentId}:${ts}:${nonce}:POST:${providerPath}`;
|
|
430
|
+
|
|
431
|
+
const keyPath = join(homedir(), ".tps", "identity", `${this.agentId}.key`);
|
|
432
|
+
let authHeader = "";
|
|
433
|
+
try {
|
|
434
|
+
const rawBuf = readFileSync(keyPath);
|
|
435
|
+
let key;
|
|
436
|
+
const rawStr = rawBuf.toString("utf-8").trim();
|
|
437
|
+
if (rawStr.startsWith("-----")) {
|
|
438
|
+
// PEM format
|
|
439
|
+
key = crypto.createPrivateKey(rawStr);
|
|
440
|
+
} else if (rawBuf.length === 32) {
|
|
441
|
+
// Raw 32-byte Ed25519 seed — wrap in PKCS8 envelope
|
|
442
|
+
const pkcs8Header = Buffer.from("302e020100300506032b657004220420", "hex");
|
|
443
|
+
key = crypto.createPrivateKey({ key: Buffer.concat([pkcs8Header, rawBuf]), format: "der", type: "pkcs8" });
|
|
444
|
+
} else {
|
|
445
|
+
// Assume base64-encoded DER/PKCS8
|
|
446
|
+
key = crypto.createPrivateKey({ key: Buffer.from(rawStr, "base64"), format: "der", type: "pkcs8" });
|
|
447
|
+
}
|
|
448
|
+
const sig = crypto.sign(null, Buffer.from(signPayload), key);
|
|
449
|
+
authHeader = `TPS-Ed25519 ${this.agentId}:${ts}:${nonce}:${sig.toString("base64")}`;
|
|
450
|
+
} catch {
|
|
451
|
+
throw new Error(`Cannot sign proxy request. Key not found at ${keyPath}`);
|
|
452
|
+
}
|
|
453
|
+
|
|
454
|
+
const res = await fetch(`${proxyUrl}${providerPath}`, {
|
|
455
|
+
method: "POST",
|
|
456
|
+
headers: {
|
|
457
|
+
"Content-Type": "application/json",
|
|
458
|
+
Authorization: authHeader,
|
|
459
|
+
},
|
|
460
|
+
body: JSON.stringify(body),
|
|
461
|
+
});
|
|
462
|
+
|
|
463
|
+
if (!res.ok) {
|
|
464
|
+
const text = await res.text().catch(() => "");
|
|
465
|
+
throw new Error(`LLM proxy error: ${res.status} ${text}`);
|
|
466
|
+
}
|
|
467
|
+
|
|
468
|
+
const data = await res.json() as Record<string, unknown>;
|
|
469
|
+
|
|
470
|
+
// Normalize response (proxy returns provider-native format)
|
|
471
|
+
if (provider === "anthropic" || provider === "claude-oauth") {
|
|
472
|
+
const content = (data as any).content ?? [];
|
|
473
|
+
const text = content.filter((b: any) => b.type === "text").map((b: any) => b.text).join("");
|
|
474
|
+
const toolCalls: ToolCall[] = content
|
|
475
|
+
.filter((b: any) => b.type === "tool_use")
|
|
476
|
+
.map((b: any) => ({ id: b.id, name: b.name, input: b.input }));
|
|
477
|
+
return {
|
|
478
|
+
content: text,
|
|
479
|
+
toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
|
|
480
|
+
inputTokens: (data as any).usage?.input_tokens ?? 0,
|
|
481
|
+
outputTokens: (data as any).usage?.output_tokens ?? 0,
|
|
482
|
+
cacheReadTokens: (data as any).usage?.cache_read_input_tokens,
|
|
483
|
+
cacheWriteTokens: (data as any).usage?.cache_creation_input_tokens,
|
|
484
|
+
// Preserve raw for history — tool_use blocks must survive into next turn
|
|
485
|
+
rawAssistantMessage: { role: "assistant", content },
|
|
486
|
+
};
|
|
487
|
+
}
|
|
488
|
+
|
|
489
|
+
// OpenAI format
|
|
490
|
+
const choice = ((data as any).choices ?? [])[0];
|
|
491
|
+
const msg = choice?.message ?? {};
|
|
492
|
+
const toolCalls: ToolCall[] = (msg.tool_calls ?? []).map((tc: any) => ({
|
|
493
|
+
id: tc.id,
|
|
494
|
+
name: tc.function.name,
|
|
495
|
+
input: JSON.parse(tc.function.arguments ?? "{}"),
|
|
496
|
+
}));
|
|
497
|
+
return {
|
|
498
|
+
content: msg.content ?? "",
|
|
499
|
+
toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
|
|
500
|
+
inputTokens: (data as any).usage?.prompt_tokens ?? 0,
|
|
501
|
+
outputTokens: (data as any).usage?.completion_tokens ?? 0,
|
|
502
|
+
};
|
|
503
|
+
}
|
|
504
|
+
|
|
164
505
|
private async completeAnthropic(request: CompletionRequest): Promise<CompletionResponse> {
|
|
165
|
-
|
|
506
|
+
let apiKey = this.config.apiKey ?? process.env.ANTHROPIC_API_KEY;
|
|
507
|
+
|
|
508
|
+
if (this.config.auth === "oauth") {
|
|
509
|
+
const oauth = loadOAuth("anthropic");
|
|
510
|
+
if (!oauth) {
|
|
511
|
+
throw new Error("Anthropic OAuth not configured. Run: tps auth login anthropic");
|
|
512
|
+
}
|
|
513
|
+
let current = oauth;
|
|
514
|
+
if (Date.now() > oauth.expiresAt - 5 * 60_000) {
|
|
515
|
+
current = await refreshAnthropicOAuthToken(oauth);
|
|
516
|
+
saveOAuth("anthropic", current);
|
|
517
|
+
}
|
|
518
|
+
apiKey = current.accessToken;
|
|
519
|
+
}
|
|
520
|
+
|
|
166
521
|
if (!apiKey) throw new Error("ANTHROPIC_API_KEY not set");
|
|
167
522
|
|
|
168
523
|
// Cache-aware system prompt (multi-block with breakpoint)
|
|
@@ -225,15 +580,34 @@ export class ProviderManager {
|
|
|
225
580
|
}
|
|
226
581
|
|
|
227
582
|
private async completeGoogle(request: CompletionRequest): Promise<CompletionResponse> {
|
|
228
|
-
|
|
229
|
-
|
|
583
|
+
let authHeader: string | undefined;
|
|
584
|
+
let url = `https://generativelanguage.googleapis.com/v1beta/models/${this.config.model}:generateContent`;
|
|
585
|
+
|
|
586
|
+
if (this.config.auth === "oauth") {
|
|
587
|
+
const oauth = loadOAuth("google");
|
|
588
|
+
if (!oauth) {
|
|
589
|
+
throw new Error("Google OAuth not configured. Run: tps auth login google");
|
|
590
|
+
}
|
|
591
|
+
let current = oauth;
|
|
592
|
+
if (Date.now() > oauth.expiresAt - 5 * 60_000) {
|
|
593
|
+
current = await refreshGoogleOAuthToken(oauth);
|
|
594
|
+
saveOAuth("google", current);
|
|
595
|
+
}
|
|
596
|
+
authHeader = `Bearer ${current.accessToken}`;
|
|
597
|
+
} else {
|
|
598
|
+
const apiKey = this.config.apiKey ?? process.env.GOOGLE_API_KEY;
|
|
599
|
+
if (!apiKey) throw new Error("GOOGLE_API_KEY not set");
|
|
600
|
+
url = `${url}?key=${apiKey}`;
|
|
601
|
+
}
|
|
230
602
|
|
|
231
|
-
const url = `https://generativelanguage.googleapis.com/v1beta/models/${this.config.model}:generateContent?key=${apiKey}`;
|
|
232
603
|
const toolPayload = this.toolSetForGoogle(request.tools);
|
|
233
604
|
|
|
234
605
|
const res = await fetch(url, {
|
|
235
606
|
method: "POST",
|
|
236
|
-
headers: {
|
|
607
|
+
headers: {
|
|
608
|
+
"Content-Type": "application/json",
|
|
609
|
+
...(authHeader ? { Authorization: authHeader } : {}),
|
|
610
|
+
},
|
|
237
611
|
body: JSON.stringify({
|
|
238
612
|
systemInstruction: request.systemPrompt
|
|
239
613
|
? { parts: [{ text: request.systemPrompt }] }
|
package/src/runtime/agent.ts
CHANGED
|
@@ -8,17 +8,39 @@ import { ContextManager } from "../io/context.js";
|
|
|
8
8
|
import { ProviderManager } from "../llm/provider.js";
|
|
9
9
|
import { BoundaryManager } from "../governance/boundary.js";
|
|
10
10
|
import { createDefaultToolset } from "../tools/index.js";
|
|
11
|
+
import { EventLogger } from "../telemetry/events.js";
|
|
12
|
+
import { FlairContextProvider } from "../io/flair.js";
|
|
13
|
+
import type { FlairClient } from "../lib/signEnvelope.js";
|
|
11
14
|
|
|
12
15
|
export class AgentRuntime {
|
|
13
16
|
private loop: EventLoop;
|
|
14
17
|
private readonly mail: MailClient;
|
|
15
18
|
private readonly boundary: BoundaryManager;
|
|
19
|
+
private readonly flair: FlairContextProvider | null;
|
|
16
20
|
|
|
17
21
|
constructor(public readonly config: AgentConfig) {
|
|
18
|
-
const
|
|
22
|
+
const events = new EventLogger(
|
|
23
|
+
config.agentId,
|
|
24
|
+
join(config.workspace, ".tps", "events"),
|
|
25
|
+
);
|
|
26
|
+
this.flair = config.flair ? new FlairContextProvider(config.agentId, config.flair) : null;
|
|
27
|
+
|
|
28
|
+
// Build FlairClient adapter for envelope verification
|
|
29
|
+
let flairClient: FlairClient | undefined;
|
|
30
|
+
if (this.flair) {
|
|
31
|
+
flairClient = {
|
|
32
|
+
getAgent: async (name: string) => {
|
|
33
|
+
const a = await this.flair!.getAgent(name);
|
|
34
|
+
if (!a) return null;
|
|
35
|
+
return { publicKey: Buffer.from(a.publicKey, "hex") };
|
|
36
|
+
},
|
|
37
|
+
};
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
const mail = new MailClient(config.mailDir, events, config.agentId, flairClient);
|
|
19
41
|
const memory = new MemoryStore(config.memoryPath);
|
|
20
42
|
const context = new ContextManager(memory, config.contextWindowTokens ?? 8000);
|
|
21
|
-
const provider = new ProviderManager(config.llm);
|
|
43
|
+
const provider = new ProviderManager(config.llm, events, config.agentId);
|
|
22
44
|
|
|
23
45
|
this.mail = mail;
|
|
24
46
|
this.boundary = new BoundaryManager(config.workspace);
|
|
@@ -29,11 +51,17 @@ export class AgentRuntime {
|
|
|
29
51
|
execAllowlist: config.execAllowlist,
|
|
30
52
|
});
|
|
31
53
|
|
|
32
|
-
|
|
54
|
+
const flairContext = this.flair
|
|
55
|
+
? (query: string) => this.flair!.buildContextBlock(query)
|
|
56
|
+
: undefined;
|
|
57
|
+
this.loop = new EventLoop({ config, memory, context, provider, tools, events, flairContext, mailClient: mail });
|
|
33
58
|
}
|
|
34
59
|
|
|
35
60
|
async start(): Promise<void> {
|
|
36
61
|
const checkInbox = async () => this.mail.checkNewMail();
|
|
62
|
+
const deliverOutbox = () => this.mail.deliverOutbox();
|
|
63
|
+
|
|
64
|
+
|
|
37
65
|
const pidPath = join(this.config.workspace, ".tps-agent.pid");
|
|
38
66
|
mkdirSync(dirname(pidPath), { recursive: true });
|
|
39
67
|
writeFileSync(pidPath, `${process.pid}\n`, "utf-8");
|
|
@@ -59,9 +87,33 @@ export class AgentRuntime {
|
|
|
59
87
|
}
|
|
60
88
|
|
|
61
89
|
async runOnce(message: string): Promise<void> {
|
|
90
|
+
if (this.flair) {
|
|
91
|
+
// Inject Flair context as a system prompt supplement
|
|
92
|
+
try {
|
|
93
|
+
const ctx = await this.flair.buildContextBlock(message.slice(0, 200));
|
|
94
|
+
if (ctx) {
|
|
95
|
+
await this.loop.runOnce(`${message}
|
|
96
|
+
|
|
97
|
+
[Flair Context]
|
|
98
|
+
${ctx}`);
|
|
99
|
+
return;
|
|
100
|
+
}
|
|
101
|
+
} catch {
|
|
102
|
+
// Fall through to normal path
|
|
103
|
+
}
|
|
104
|
+
}
|
|
62
105
|
await this.loop.runOnce(message);
|
|
63
106
|
}
|
|
64
107
|
|
|
108
|
+
async writeConversationMemory(id: string, content: string): Promise<void> {
|
|
109
|
+
if (!this.flair) return;
|
|
110
|
+
try {
|
|
111
|
+
await this.flair.writeMemory(id, content, "conversation");
|
|
112
|
+
} catch {
|
|
113
|
+
// Non-fatal — local memory still works
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
|
|
65
117
|
getState(): string {
|
|
66
118
|
return this.loop.getState();
|
|
67
119
|
}
|