Hynes/Void-Homelab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(companion): Dross persona (Cradle) + migration 008 rename; remove dead API-key path

Browse Source 
- system prompt = Dross (Ozriel's construct fragment, per Void 1.0), with tool guidance
- migration 008 renames the seeded agent 'companion' → display name 'Dross'
- removed lib/ai/anthropic.js + lib/ai/agent/runtime.js + tests + @anthropic-ai/sdk dep (companion now runs via the claude CLI; kept lib/ai/secret.js for the Vaultwarden roadmap)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
root
2026-06-01 22:58:43 +10:00
parent d35e43a8ad
commit 8ce97bbacc
8 changed files with 29 additions and 500 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
lib/ai/agent/runtime.js
View File

@@ -1,58 +0,0 @@
// Tool-use loop. callModel + registry injected (no network here).
// Emits: { type:'tool', tool, args, status } | { type:'delta', text }
// | { type:'draft', pending_change_id, summary }
// Returns: { text, toolTrace, draftIds, usage, stoppedOnGuard }
export async function runTurn({ callModel, registry, system, messages, ctx, onEvent, maxIterations = 6 }) {
const convo = [...messages];
const toolTrace = [];
const draftIds = [];
let usage = {};
let stoppedOnGuard = false;
for (let i = 0; i < maxIterations; i++) {
const res = await callModel({
system,
messages: convo,
tools: registry.toAnthropicTools(),
onTextDelta: (t) => onEvent?.({ type: 'delta', text: t })
});
usage = res.usage || usage;
if (!res.toolUses?.length) {
return { text: res.text, toolTrace, draftIds, usage, stoppedOnGuard };
}
// Record the assistant turn (text + tool_use blocks) for the next round.
convo.push({
role: 'assistant',
content: [
...(res.text ? [{ type: 'text', text: res.text }] : []),
...res.toolUses.map(t => ({ type: 'tool_use', id: t.id, name: t.name, input: t.input }))
]
});
const toolResults = [];
for (const call of res.toolUses) {
const tool = registry.getTool(call.name);
let result;
try {
result = tool ? await tool.handler(call.input, ctx) : { error: `unknown tool ${call.name}` };
} catch (e) {
result = { error: String(e?.message || e) };
}
const status = result?.error ? 'error' : 'done';
toolTrace.push({ tool: call.name, args: call.input, ok: !result?.error });
onEvent?.({ type: 'tool', tool: call.name, args: call.input, status });
if (result?.pending_change_id) {
draftIds.push(result.pending_change_id);
onEvent?.({ type: 'draft', pending_change_id: result.pending_change_id, summary: result.summary });
}
toolResults.push({ type: 'tool_result', tool_use_id: call.id, content: JSON.stringify(result) });
}
convo.push({ role: 'user', content: toolResults });
if (i === maxIterations - 1) stoppedOnGuard = true;
}
return { text: '', toolTrace, draftIds, usage, stoppedOnGuard };
}

80
lib/ai/anthropic.js
View File

@@ -1,80 +0,0 @@
import Anthropic from '@anthropic-ai/sdk';
import { resolveSecret } from './secret.js';
export const DEFAULT_MODEL = process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-6';
/**
* Build an Anthropic client, resolving the API key via the secret resolver.
* Key reference can be overridden with ANTHROPIC_API_KEY_REF env var.
*/
export function getAnthropicClient() {
const key = resolveSecret(process.env.ANTHROPIC_API_KEY_REF || 'env:ANTHROPIC_API_KEY');
if (!key) {
throw new Error(
'Anthropic API key not configured (set ANTHROPIC_API_KEY or ANTHROPIC_API_KEY_REF)'
);
}
return new Anthropic({ apiKey: key });
}
/**
* Factory that returns a callModel function bound to a specific client + model.
*
* @param {object} opts
* @param {object} opts.client - Anthropic client (or fake for tests)
* @param {string} [opts.model] - Model ID (default: DEFAULT_MODEL)
* @param {number} [opts.maxTokens] - max_tokens (default: 1024)
* @returns {Function} callModel({ system, messages, tools, onTextDelta })
*
* callModel returns a stable shape:
* { text: string, toolUses: [{id, name, input}], stopReason: string, usage: object }
*
* Text deltas are streamed via onTextDelta(chunk) as they arrive.
* Tool-use blocks are collected from the final assembled message.
*/
export function makeCallModel({ client, model = DEFAULT_MODEL, maxTokens = 1024 }) {
return async function callModel({ system, messages, tools, onTextDelta }) {
// client.messages.stream returns a MessageStream: AsyncIterable<MessageStreamEvent>
// with a finalMessage() method that resolves to the assembled Message.
const stream = client.messages.stream({
model,
max_tokens: maxTokens,
...(system !== undefined && { system }),
messages,
...(tools !== undefined && tools !== null && { tools }),
});
// Iterate events; fire onTextDelta for text_delta events only.
// RawContentBlockDeltaEvent: { type: 'content_block_delta', index, delta }
// TextDelta: { type: 'text_delta', text }
for await (const event of stream) {
if (
event.type === 'content_block_delta' &&
event.delta?.type === 'text_delta'
) {
onTextDelta?.(event.delta.text);
}
}
// finalMessage() resolves to the fully assembled Message object.
const final = await stream.finalMessage();
// Collect text from all text blocks (typically just one, but join defensively).
const text = final.content
.filter((b) => b.type === 'text')
.map((b) => b.text)
.join('');
// Collect tool_use blocks, normalising to a stable {id, name, input} shape.
const toolUses = final.content
.filter((b) => b.type === 'tool_use')
.map((b) => ({ id: b.id, name: b.name, input: b.input }));
return {
text,
toolUses,
stopReason: final.stop_reason,
usage: final.usage,
};
};
}