c858cb816c
Add git, gh, openssh-client, curl, and sudo to the computer image with a docker smoke test. Mount deployment-owner project workspacePath at /home/rakazo/project, align /home/rakazo file paths with shell, and resolve default branch from origin/HEAD. Inject the owner GitHub token from encrypted deployment settings only into project computers; enforce branch-only push, block force-push, and require approval before the first push or gh pr in a run. Add runaway guards (tool fuse and stall pause), collapse live narration, fix streaming progress merge, DE run strings, and Lead as the project main Oo name. Fix evo-deploy test flake. Co-authored-by: cynarAI <cynarAI@users.noreply.github.com>
699 lines
21 KiB
TypeScript
699 lines
21 KiB
TypeScript
import { randomUUID } from "node:crypto";
|
|
import type { Agent, AgentMessage, AgentToolResult } from "@earendil-works/pi-agent-core";
|
|
import {
|
|
type Api,
|
|
clampThinkingLevel,
|
|
type Model,
|
|
type Models,
|
|
type ModelThinkingLevel,
|
|
type SimpleStreamOptions,
|
|
Type,
|
|
} from "@earendil-works/pi-ai";
|
|
import { builtinModels } from "@earendil-works/pi-ai/providers/all";
|
|
import type {
|
|
AgentRunRequest,
|
|
AgentRuntimeEvent,
|
|
AgentSteeringMessage,
|
|
AgentToolExecutionResult,
|
|
} from "@rakazo/adapter-kit";
|
|
import { getLogger } from "@rakazo/logging";
|
|
import { DEFAULT_OPENROUTER_MODEL_ID } from "./deployment-model.js";
|
|
import { PiRuntimeCredentialStore, toOAuthCredential } from "./pi-credentials.js";
|
|
import { registerLocalProvider } from "./pi-local-provider.js";
|
|
import {
|
|
OPENAI_COMPATIBLE_PROVIDER_ID,
|
|
registerOpenAiCompatibleCatalog,
|
|
registerOpenAiCompatibleRuntime,
|
|
} from "./pi-openai-compatible-provider.js";
|
|
import {
|
|
billedPromptTokens,
|
|
clipToolResultContent,
|
|
clipToolResultText,
|
|
MODEL_STREAM_MAX_RETRIES,
|
|
MODEL_STREAM_TIMEOUT_MS,
|
|
resolveCompletionMaxTokens,
|
|
} from "./pi-runtime-limits.js";
|
|
|
|
// --- Model catalog ---
|
|
|
|
const REASONING_MODEL_THINKING_LEVEL: ModelThinkingLevel = "medium";
|
|
|
|
let catalogModelsCache: Models | undefined;
|
|
|
|
export function catalogModels(): Models {
|
|
catalogModelsCache ??= registerOpenAiCompatibleCatalog(registerLocalProvider(builtinModels()));
|
|
return catalogModelsCache;
|
|
}
|
|
|
|
export function thinkingLevelFor(
|
|
model: Model<Api>,
|
|
preferred?: ModelThinkingLevel | null,
|
|
): ModelThinkingLevel {
|
|
if (!model.reasoning) return "off";
|
|
if (preferred) return clampThinkingLevel(model, preferred);
|
|
return clampThinkingLevel(model, REASONING_MODEL_THINKING_LEVEL);
|
|
}
|
|
|
|
// --- Tool call budget ---
|
|
|
|
export interface ToolCallBudget {
|
|
count: number;
|
|
exceeded: boolean;
|
|
limit: number;
|
|
inFlight: number;
|
|
}
|
|
|
|
// Optional fuse is process-local. continueRun on another worker starts at zero.
|
|
const toolCallBudgetsByRun = new Map<string, ToolCallBudget>();
|
|
|
|
/** Optional self-host fuse. Unset, empty, or 0 means unlimited (default). */
|
|
export function maxToolCallsPerTurn(env: NodeJS.ProcessEnv = process.env): number {
|
|
const raw = env.MAX_TOOL_CALLS_PER_TURN?.trim();
|
|
if (!raw) return 48;
|
|
const parsed = Number(raw);
|
|
if (!Number.isFinite(parsed) || parsed <= 0) return 0;
|
|
return Math.floor(parsed);
|
|
}
|
|
|
|
export function toolCallBudgetFor(runId: string): ToolCallBudget {
|
|
const existing = toolCallBudgetsByRun.get(runId);
|
|
if (existing) {
|
|
existing.inFlight = 0;
|
|
existing.limit = maxToolCallsPerTurn();
|
|
if (existing.exceeded) {
|
|
existing.exceeded = false;
|
|
existing.count = 0;
|
|
}
|
|
return existing;
|
|
}
|
|
const budget: ToolCallBudget = {
|
|
count: 0,
|
|
exceeded: false,
|
|
limit: maxToolCallsPerTurn(),
|
|
inFlight: 0,
|
|
};
|
|
if (budget.limit > 0) toolCallBudgetsByRun.set(runId, budget);
|
|
return budget;
|
|
}
|
|
|
|
export function releaseToolCallBudget(runId: string, keepForResume: boolean) {
|
|
if (!keepForResume) toolCallBudgetsByRun.delete(runId);
|
|
}
|
|
|
|
export function maybeAbortToolCallBudget(host: {
|
|
toolCallBudget: ToolCallBudget;
|
|
abortTurn(): void;
|
|
}): void {
|
|
if (host.toolCallBudget.exceeded && host.toolCallBudget.inFlight === 0) {
|
|
host.abortTurn();
|
|
}
|
|
}
|
|
|
|
export function beginToolCall(host: {
|
|
toolCallBudget: ToolCallBudget;
|
|
abortTurn(): void;
|
|
queue: { push(event: AgentRuntimeEvent): void };
|
|
}): boolean {
|
|
const budget = host.toolCallBudget;
|
|
if (budget.limit <= 0) {
|
|
budget.count += 1;
|
|
return true;
|
|
}
|
|
if (budget.exceeded) {
|
|
maybeAbortToolCallBudget(host);
|
|
return false;
|
|
}
|
|
budget.count += 1;
|
|
if (budget.count <= budget.limit) {
|
|
budget.inFlight += 1;
|
|
return true;
|
|
}
|
|
if (!budget.exceeded) {
|
|
budget.exceeded = true;
|
|
host.queue.push({
|
|
type: "progress",
|
|
text: `Stopped: more than ${budget.limit} tool calls in one turn.`,
|
|
});
|
|
}
|
|
maybeAbortToolCallBudget(host);
|
|
return false;
|
|
}
|
|
|
|
export function endToolCall(host: { toolCallBudget: ToolCallBudget; abortTurn(): void }): void {
|
|
host.toolCallBudget.inFlight = Math.max(0, host.toolCallBudget.inFlight - 1);
|
|
maybeAbortToolCallBudget(host);
|
|
}
|
|
|
|
export function toolCallBudgetExceededMessage(limit: number): string {
|
|
return `I stopped after reaching the limit of ${limit} tool calls in this turn. Choose whether to continue with more tool calls or stop for now.`;
|
|
}
|
|
|
|
/** Pause a long run when no user-visible progress landed for this many milliseconds. */
|
|
export function runStallWithoutProgressMs(env: NodeJS.ProcessEnv = process.env): number {
|
|
const raw = env.RUN_STALL_WITHOUT_PROGRESS_MS?.trim();
|
|
if (!raw) return 15 * 60_000;
|
|
const parsed = Number(raw);
|
|
if (!Number.isFinite(parsed) || parsed <= 0) return 0;
|
|
return Math.floor(parsed);
|
|
}
|
|
|
|
// --- Model resolution ---
|
|
|
|
export function configuredOpenRouterModel(id: string): Model<"openai-completions"> {
|
|
return {
|
|
id,
|
|
name: id,
|
|
api: "openai-completions",
|
|
provider: "openrouter",
|
|
baseUrl: "https://openrouter.ai/api/v1",
|
|
reasoning: true,
|
|
input: ["text"],
|
|
cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
|
|
contextWindow: 16_384,
|
|
maxTokens: 4_096,
|
|
};
|
|
}
|
|
|
|
export function modelsForRequest(
|
|
request: Pick<AgentRunRequest, "model">,
|
|
provider: string,
|
|
): Models {
|
|
const oauth = request.model.oauth;
|
|
if (oauth) {
|
|
const persist = oauth.persist;
|
|
return registerOpenAiCompatibleCatalog(
|
|
registerLocalProvider(
|
|
builtinModels({
|
|
credentials: new PiRuntimeCredentialStore(
|
|
provider,
|
|
toOAuthCredential(oauth.credential),
|
|
persist ? (next) => persist(next) : undefined,
|
|
),
|
|
}),
|
|
),
|
|
);
|
|
}
|
|
if (
|
|
provider === OPENAI_COMPATIBLE_PROVIDER_ID &&
|
|
request.model.baseUrl &&
|
|
request.model.id.trim()
|
|
) {
|
|
const models = registerOpenAiCompatibleCatalog(registerLocalProvider(builtinModels()));
|
|
return registerOpenAiCompatibleRuntime(models, {
|
|
modelId: request.model.id,
|
|
baseUrl: request.model.baseUrl,
|
|
reasoning: request.model.reasoning,
|
|
acceptsImages: request.model.acceptsImages,
|
|
maxTokens: request.model.maxTokens,
|
|
contextWindow: request.model.contextWindow,
|
|
});
|
|
}
|
|
return catalogModels();
|
|
}
|
|
|
|
export function resolveRuntimeModel(modelConfig: AgentRunRequest["model"]): {
|
|
provider: string;
|
|
modelId: string;
|
|
models: Models;
|
|
model: Model<Api> | undefined;
|
|
apiKey: string | undefined;
|
|
} {
|
|
const provider = modelConfig.provider === "scripted" ? "openrouter" : modelConfig.provider;
|
|
const envDefaultModel = process.env.PI_DEFAULT_MODEL?.trim();
|
|
const envDefaultProvider = process.env.PI_DEFAULT_PROVIDER?.trim() || "openrouter";
|
|
const modelId =
|
|
modelConfig.id === "scripted"
|
|
? envDefaultModel || DEFAULT_OPENROUTER_MODEL_ID
|
|
: modelConfig.id.trim();
|
|
const models = modelsForRequest({ model: modelConfig }, provider);
|
|
let model = models.getModel(provider, modelId);
|
|
if (!model && provider !== "openrouter" && provider !== OPENAI_COMPATIBLE_PROVIDER_ID) {
|
|
model = models.getModel("openrouter", modelId);
|
|
}
|
|
if (
|
|
!model &&
|
|
provider === "openrouter" &&
|
|
envDefaultProvider === "openrouter" &&
|
|
modelId === envDefaultModel
|
|
) {
|
|
model = configuredOpenRouterModel(modelId);
|
|
}
|
|
const apiKey = modelConfig.oauth
|
|
? undefined
|
|
: modelConfig.provider === OPENAI_COMPATIBLE_PROVIDER_ID
|
|
? modelConfig.apiKey || "local"
|
|
: (modelConfig.apiKey ??
|
|
(provider === "openrouter" ? process.env.OPENROUTER_API_KEY : undefined));
|
|
return { provider, modelId, models, model, apiKey };
|
|
}
|
|
|
|
// --- Image helpers ---
|
|
|
|
export function toPiImages(images: AgentRunRequest["currentTurnImages"]) {
|
|
return (images ?? []).map((image) => ({
|
|
type: "image" as const,
|
|
data: Buffer.from(image.data).toString("base64"),
|
|
mimeType: image.mimeType,
|
|
}));
|
|
}
|
|
|
|
// --- Steering message removal ---
|
|
|
|
export function withoutSteeringMessages(
|
|
history: AgentRunRequest["history"],
|
|
steering: AgentSteeringMessage[],
|
|
): AgentRunRequest["history"] {
|
|
if (steering.length === 0) return history;
|
|
const result = [...history];
|
|
let beforeIndex = result.length - 1;
|
|
for (let steeringIndex = steering.length - 1; steeringIndex >= 0; steeringIndex -= 1) {
|
|
const steeringMessage = steering[steeringIndex];
|
|
for (let index = beforeIndex; index >= 0; index -= 1) {
|
|
const message = result[index];
|
|
if (
|
|
message?.role !== "user" ||
|
|
(message.id
|
|
? message.id !== steeringMessage?.messageId
|
|
: message.content !== (steeringMessage?.historyText ?? steeringMessage?.text))
|
|
) {
|
|
continue;
|
|
}
|
|
result.splice(index, 1);
|
|
beforeIndex = index - 1;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// --- Request secret arguments ---
|
|
|
|
export function prepareRequestSecretArguments(raw: Record<string, unknown>) {
|
|
return {
|
|
label: String(raw.label ?? "Code"),
|
|
purpose: String(raw.purpose ?? "otp"),
|
|
...(raw.connectionId ? { connectionId: String(raw.connectionId) } : {}),
|
|
...(raw.credential ? { credential: raw.credential } : {}),
|
|
...(raw.replace === true ? { replace: true } : {}),
|
|
};
|
|
}
|
|
|
|
// --- Screenshot context pruning ---
|
|
|
|
const DEFAULT_COMPUTER_SCREENSHOTS_TO_KEEP = 2;
|
|
|
|
export function pruneComputerScreenshotContext(
|
|
messages: AgentMessage[],
|
|
maxImagesPerPrompt?: number,
|
|
): AgentMessage[] {
|
|
const imageLimit =
|
|
maxImagesPerPrompt === undefined
|
|
? undefined
|
|
: Number.isFinite(maxImagesPerPrompt)
|
|
? Math.max(0, Math.floor(maxImagesPerPrompt))
|
|
: DEFAULT_COMPUTER_SCREENSHOTS_TO_KEEP;
|
|
let remaining = imageLimit ?? DEFAULT_COMPUTER_SCREENSHOTS_TO_KEEP;
|
|
if (imageLimit !== undefined) {
|
|
const nonScreenshotImages = messages.reduce(
|
|
(count, message) =>
|
|
isComputerScreenshotMessage(message) ? count : count + imagePartCount(message),
|
|
0,
|
|
);
|
|
if (nonScreenshotImages > imageLimit) {
|
|
throw new Error(
|
|
`The configured model image limit is ${imageLimit}, but the prompt contains ${nonScreenshotImages} non-screenshot images.`,
|
|
);
|
|
}
|
|
remaining = imageLimit - nonScreenshotImages;
|
|
}
|
|
let transformed: AgentMessage[] | undefined;
|
|
for (let index = messages.length - 1; index >= 0; index -= 1) {
|
|
const message = messages[index];
|
|
if (!isComputerScreenshotMessage(message)) continue;
|
|
const images = imagePartCount(message);
|
|
if (remaining >= images) {
|
|
remaining -= images;
|
|
continue;
|
|
}
|
|
transformed ??= [...messages];
|
|
transformed[index] = {
|
|
...message,
|
|
content: message.content.filter((part) => part.type !== "image"),
|
|
};
|
|
}
|
|
return transformed ?? messages;
|
|
}
|
|
|
|
export function imagePartCount(message: AgentMessage): number {
|
|
if (!("content" in message) || !Array.isArray(message.content)) return 0;
|
|
return message.content.filter(
|
|
(part: unknown) =>
|
|
typeof part === "object" &&
|
|
part !== null &&
|
|
"type" in part &&
|
|
(part as { type?: string }).type === "image",
|
|
).length;
|
|
}
|
|
|
|
export function isComputerScreenshotMessage(
|
|
message: AgentMessage | undefined,
|
|
): message is Extract<AgentMessage, { role: "toolResult" }> {
|
|
if (
|
|
message?.role !== "toolResult" ||
|
|
!message.content.some((part) => (part as { type?: string }).type === "image")
|
|
) {
|
|
return false;
|
|
}
|
|
const details = message.details;
|
|
return Boolean(
|
|
details &&
|
|
typeof details === "object" &&
|
|
"frameId" in details &&
|
|
typeof (details as { frameId?: unknown }).frameId === "string",
|
|
);
|
|
}
|
|
|
|
// --- Type guards ---
|
|
|
|
export function isAgentToolExecutionResult(result: unknown): result is AgentToolExecutionResult {
|
|
if (
|
|
!result ||
|
|
typeof result !== "object" ||
|
|
(result as { kind?: unknown }).kind !== "agent_tool_result" ||
|
|
!("content" in result)
|
|
) {
|
|
return false;
|
|
}
|
|
const content = (result as { content?: unknown }).content;
|
|
return (
|
|
Array.isArray(content) &&
|
|
content.every(
|
|
(item) =>
|
|
item &&
|
|
typeof item === "object" &&
|
|
((item as { type?: unknown }).type === "text" ||
|
|
(item as { type?: unknown }).type === "image"),
|
|
)
|
|
);
|
|
}
|
|
|
|
// --- JSON Schema helpers ---
|
|
|
|
export function jsonSchemaParameters(
|
|
schema: Record<string, unknown>,
|
|
): ReturnType<typeof Type.Object> {
|
|
const alternatives = Array.isArray(schema.oneOf)
|
|
? schema.oneOf
|
|
: Array.isArray(schema.anyOf)
|
|
? schema.anyOf
|
|
: undefined;
|
|
if (alternatives && alternatives.length > 0 && schema.properties == null) {
|
|
return Type.Union(
|
|
alternatives.map((variant) => jsonSchemaParameters(variant as Record<string, unknown>)),
|
|
) as unknown as ReturnType<typeof Type.Object>;
|
|
}
|
|
const properties = (schema.properties ?? {}) as Record<string, unknown>;
|
|
const required = new Set(Array.isArray(schema.required) ? schema.required.map(String) : []);
|
|
const fields: Record<string, ReturnType<typeof Type.Optional>> = {};
|
|
for (const [key, spec] of Object.entries(properties)) {
|
|
const field = jsonField(spec);
|
|
fields[key] = (required.has(key) ? field : Type.Optional(field)) as unknown as ReturnType<
|
|
typeof Type.Optional
|
|
>;
|
|
}
|
|
return schema.additionalProperties === false
|
|
? Type.Object(fields, { additionalProperties: false })
|
|
: Type.Object(fields);
|
|
}
|
|
|
|
export function enumUnion(values: readonly unknown[]) {
|
|
const members = values.map((value) =>
|
|
value === null
|
|
? Type.Null()
|
|
: typeof value === "string" || typeof value === "number" || typeof value === "boolean"
|
|
? Type.Literal(value)
|
|
: undefined,
|
|
);
|
|
return members.every((member) => member !== undefined) ? Type.Union(members) : undefined;
|
|
}
|
|
|
|
export function jsonField(spec: unknown): ReturnType<typeof Type.String> {
|
|
const definition = spec && typeof spec === "object" ? (spec as Record<string, unknown>) : {};
|
|
if (Array.isArray(definition.enum) && definition.enum.length > 0) {
|
|
const union = enumUnion(definition.enum);
|
|
if (union) return union as never;
|
|
}
|
|
if ("const" in definition) {
|
|
const literal = enumUnion([definition.const]);
|
|
if (literal) return literal as never;
|
|
}
|
|
const variants = Array.isArray(definition.oneOf)
|
|
? definition.oneOf
|
|
: Array.isArray(definition.anyOf)
|
|
? definition.anyOf
|
|
: undefined;
|
|
if (variants && variants.length > 0) {
|
|
return Type.Union(variants.map((variant) => jsonField(variant))) as never;
|
|
}
|
|
if (Array.isArray(definition.type) && definition.type.length > 0) {
|
|
return Type.Union(definition.type.map((type) => jsonField({ ...definition, type }))) as never;
|
|
}
|
|
const type = "type" in definition ? String(definition.type) : "string";
|
|
if (type === "null") return Type.Null() as never;
|
|
if (type === "number" || type === "integer") return Type.Number() as never;
|
|
if (type === "boolean") return Type.Boolean() as never;
|
|
if (type === "array") {
|
|
const options: {
|
|
minItems?: number;
|
|
maxItems?: number;
|
|
uniqueItems?: boolean;
|
|
} = {};
|
|
if (typeof definition.minItems === "number") options.minItems = definition.minItems;
|
|
if (typeof definition.maxItems === "number") options.maxItems = definition.maxItems;
|
|
if (definition.uniqueItems === true) options.uniqueItems = true;
|
|
return Type.Array(jsonField(definition.items), options) as never;
|
|
}
|
|
if (type === "object") return jsonSchemaParameters(definition) as never;
|
|
return Type.String();
|
|
}
|
|
|
|
// --- Result helpers ---
|
|
|
|
export function summarizeToolResult(result: unknown) {
|
|
try {
|
|
const text = JSON.stringify(result);
|
|
if (!text) return "ok";
|
|
return clipToolResultText(text);
|
|
} catch {
|
|
return "ok";
|
|
}
|
|
}
|
|
|
|
export function boundAgentToolResult<T>(result: AgentToolResult<T>): AgentToolResult<T> {
|
|
if (!result || !Array.isArray(result.content)) return result;
|
|
return {
|
|
...result,
|
|
content: clipToolResultContent(result.content),
|
|
};
|
|
}
|
|
|
|
export function assistantText(message: unknown): string {
|
|
if (!message || typeof message !== "object" || !("content" in message)) return "";
|
|
const content = (message as { content?: unknown }).content;
|
|
if (typeof content === "string") return content;
|
|
if (!Array.isArray(content)) return "";
|
|
return content
|
|
.map((part) =>
|
|
part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part
|
|
? String(part.text)
|
|
: "",
|
|
)
|
|
.join("");
|
|
}
|
|
|
|
// --- Sanitization ---
|
|
|
|
export function sanitizeSensitiveText(message: string) {
|
|
return message
|
|
.replace(/sk-or-v1-[a-zA-Z0-9]+/g, "[redacted]")
|
|
.replace(/sk-[a-zA-Z0-9-]+/g, "[redacted]")
|
|
.replace(/Bearer\s+[^\s"',;&]+/gi, "Bearer [redacted]")
|
|
.replace(/eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/g, "[redacted]")
|
|
.replace(/COMPOSIO_API_KEY[=:]?\s*\S+/gi, "COMPOSIO_API_KEY=[redacted]")
|
|
.replace(
|
|
/((?:api[_-]?key|access[_-]?token|password|secret)\s*[=:]\s*)[^\s"',;&]+/gi,
|
|
"$1[redacted]",
|
|
)
|
|
.replace(/((?:auth|authorization)\s*[=:]\s*)(?!Bearer\b)[^\s"',;&]+/gi, "$1[redacted]");
|
|
}
|
|
|
|
export function redactActivityUrl(value: unknown): string {
|
|
const raw = String(value ?? "").trim();
|
|
if (!raw) return raw;
|
|
try {
|
|
const url = new URL(raw);
|
|
url.username = "";
|
|
url.password = "";
|
|
url.search = "";
|
|
url.hash = "";
|
|
return url.toString();
|
|
} catch {
|
|
return "[invalid URL]";
|
|
}
|
|
}
|
|
|
|
export function sanitizeError(message: string) {
|
|
return sanitizeSensitiveText(message);
|
|
}
|
|
|
|
// --- Session ID & provider helpers ---
|
|
|
|
export function conversationSessionId(threadId: string, botId: string, agentId?: string): string {
|
|
return agentId ? `${threadId}:${botId}:${agentId}` : `${threadId}:${botId}`;
|
|
}
|
|
|
|
export function isOpenCodeProvider(provider: string): boolean {
|
|
return provider === "opencode" || provider === "opencode-go";
|
|
}
|
|
|
|
const OPENCODE_SESSION_ERROR = "OpenCode rejected this chat session. Send the message again.";
|
|
|
|
export function looksLikeOpenCodeSessionError(message: string): boolean {
|
|
return (
|
|
/x-opencode-session/i.test(message) ||
|
|
/session\s*(id|header|required|missing|invalid|expired|stale)/i.test(message) ||
|
|
/model is unavailable/i.test(message)
|
|
);
|
|
}
|
|
|
|
export function sanitizeProviderError(provider: string, message: string): string {
|
|
const sanitized = sanitizeError(message);
|
|
if (isOpenCodeProvider(provider) && looksLikeOpenCodeSessionError(sanitized)) {
|
|
return OPENCODE_SESSION_ERROR;
|
|
}
|
|
return sanitized;
|
|
}
|
|
|
|
// --- Queue & gate ---
|
|
|
|
export interface EventQueue {
|
|
push(event: AgentRuntimeEvent): void;
|
|
fail(error: Error): void;
|
|
close(): void;
|
|
iterate(): AsyncIterable<AgentRuntimeEvent>;
|
|
}
|
|
|
|
export function createQueue(): EventQueue {
|
|
const items: AgentRuntimeEvent[] = [];
|
|
let wake: (() => void) | undefined;
|
|
let closed = false;
|
|
let failure: Error | undefined;
|
|
return {
|
|
push(event) {
|
|
items.push(event);
|
|
wake?.();
|
|
},
|
|
fail(error) {
|
|
failure = error;
|
|
closed = true;
|
|
wake?.();
|
|
},
|
|
close() {
|
|
closed = true;
|
|
wake?.();
|
|
},
|
|
async *iterate() {
|
|
while (true) {
|
|
if (items.length) {
|
|
yield items.shift()!;
|
|
continue;
|
|
}
|
|
if (failure) throw failure;
|
|
if (closed) return;
|
|
await new Promise<void>((resolve) => {
|
|
wake = resolve;
|
|
});
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
export function createGate(max: number) {
|
|
let active = 0;
|
|
const waiters: Array<() => void> = [];
|
|
return {
|
|
async acquire() {
|
|
if (active >= max) {
|
|
await new Promise<void>((resolve) => {
|
|
waiters.push(resolve);
|
|
});
|
|
}
|
|
active += 1;
|
|
},
|
|
release() {
|
|
active = Math.max(0, active - 1);
|
|
waiters.shift()?.();
|
|
},
|
|
};
|
|
}
|
|
|
|
// --- Model completion ---
|
|
|
|
export function modelForCompletion(model: Model<Api>, configuredMaxTokens?: number): Model<Api> {
|
|
const maxTokens = resolveCompletionMaxTokens(model.maxTokens, configuredMaxTokens);
|
|
if (maxTokens === model.maxTokens) return model;
|
|
return { ...model, maxTokens };
|
|
}
|
|
|
|
// --- Reliable streaming ---
|
|
|
|
export function reliableStreamOptions(
|
|
model: Pick<Model<Api>, "api" | "provider" | "maxTokens">,
|
|
options?: SimpleStreamOptions,
|
|
configuredMaxTokens?: number,
|
|
): SimpleStreamOptions {
|
|
let next: SimpleStreamOptions = {
|
|
...options,
|
|
timeoutMs: options?.timeoutMs ?? MODEL_STREAM_TIMEOUT_MS,
|
|
maxRetries: options?.maxRetries ?? MODEL_STREAM_MAX_RETRIES,
|
|
maxTokens: resolveCompletionMaxTokens(model.maxTokens, configuredMaxTokens, options?.maxTokens),
|
|
};
|
|
|
|
if (model.provider === "openai-codex" || model.api === "openai-codex-responses") {
|
|
next = { ...next, transport: "sse" };
|
|
}
|
|
|
|
if (isOpenCodeProvider(model.provider)) {
|
|
const sessionId = next.sessionId?.trim() || randomUUID();
|
|
next = {
|
|
...next,
|
|
sessionId,
|
|
headers: {
|
|
"x-opencode-session": sessionId,
|
|
"x-opencode-client": "rakazo",
|
|
...next.headers,
|
|
},
|
|
};
|
|
}
|
|
|
|
return next;
|
|
}
|
|
|
|
// --- Tool host interface ---
|
|
|
|
export interface ToolHost {
|
|
queue: EventQueue;
|
|
request: AgentRunRequest;
|
|
models: Models;
|
|
model: Model<Api>;
|
|
apiKey: string | undefined;
|
|
nestedAgents: Set<Agent>;
|
|
subagentGate: { acquire(): Promise<void>; release(): void };
|
|
toolCallBudget: ToolCallBudget;
|
|
toolCallSeq: { value: number };
|
|
abortTurn(): void;
|
|
signal: AbortSignal;
|
|
depth: number;
|
|
pausePending: boolean;
|
|
}
|