@stage-labs/metro 0.1.0-beta.21 → 0.1.0-beta.211

package/runtime/node_modules/@metro-labs/daemon/src/gateway/gemini-setup.ts

@@ -0,0 +1,150 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import { GeminiAuthError, type GeminiTokens } from './gemini-auth.js';
+import { API, clientHeaders, clientMetadata, setupBases, type Bases } from './gemini-client.js';
+import { nonEmpty } from './text.js';
+
+const FREE_TIER = 'free-tier';
+const PROJECT_RE = /^[a-z][a-z0-9-]{4,28}[a-z0-9]$/;
+const POLL_MS = 5000;
+const POLL_MAX = 24;
+
+export interface Onboarded {
+  project: string;
+  tier: string | null;
+}
+
+
+export function parseGeminiProject(value: unknown): string | null {
+  const project = typeof value === 'string' ? value.trim() : '';
+  if (project === '') return null;
+  if (!PROJECT_RE.test(project)) throw new GeminiAuthError('that is not a Google Cloud project id: 6 to 30 lowercase letters, digits and dashes, starting with a letter');
+  return project;
+}
+
+class Retryable extends Error {}
+
+async function callOne(base: string, method: string, token: string, body: unknown, fetchImpl: typeof fetch): Promise<Record<string, unknown>> {
+  let res: Response;
+  try {
+    res = await fetchImpl(`${base}/${API}:${method}`, {
+      method: 'POST',
+      headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json', ...clientHeaders() },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(30_000),
+    });
+  } catch (err) {
+    throw new Retryable(`could not reach Google Code Assist: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const answer: unknown = await res.json().catch(() => null);
+  if (!res.ok) {
+    const detail = (isRecord(answer) && isRecord(answer.error) ? nonEmpty(answer.error.message) : null) ?? `Google Code Assist answered ${String(res.status)} on ${method}`;
+    throw res.status >= 500 ? new Retryable(detail) : new GeminiAuthError(detail);
+  }
+  return isRecord(answer) ? answer : {};
+}
+
+async function call(bases: string[], method: string, token: string, body: unknown, fetchImpl: typeof fetch): Promise<Record<string, unknown>> {
+  let last = 'no Code Assist endpoint to call';
+  for (const base of bases) {
+    try {
+      return await callOne(base, method, token, body, fetchImpl);
+    } catch (err) {
+      if (!(err instanceof Retryable)) throw err;
+      last = err.message;
+    }
+  }
+  throw new GeminiAuthError(last);
+}
+
+const tierOf = (load: Record<string, unknown>): { id: string | null; name: string | null } => {
+  const tier = isRecord(load.paidTier) ? load.paidTier : isRecord(load.currentTier) ? load.currentTier : null;
+  return { id: tier === null ? null : nonEmpty(tier.id), name: tier === null ? null : nonEmpty(tier.name) };
+};
+
+async function waitOperation(base: string, token: string, first: Record<string, unknown>, fetchImpl: typeof fetch): Promise<Record<string, unknown>> {
+  let op = first;
+  for (let i = 0; op.done !== true && i < POLL_MAX; i += 1) {
+    const name = nonEmpty(op.name);
+    if (name === null) break;
+    await new Promise((r) => setTimeout(r, POLL_MS));
+    const res = await fetchImpl(`${base}/${API}/${name}`, { headers: { authorization: `Bearer ${token}`, ...clientHeaders() }, signal: AbortSignal.timeout(30_000) });
+    const answer: unknown = await res.json().catch(() => null);
+    op = isRecord(answer) ? answer : {};
+  }
+  return op;
+}
+
+const REASONS: Record<string, string> = {
+  DASHER_USER: 'this is a Google Workspace account; the individual tier needs a personal Google account',
+  NON_USER_ACCOUNT: 'this is not a user account',
+  RESTRICTED_AGE: 'the account does not meet the age requirement',
+  UNSUPPORTED_LOCATION: 'Gemini Code Assist for individuals is not offered where this account is located',
+  UNKNOWN_LOCATION: 'Google could not tell where this account is located',
+  RESTRICTED_NETWORK: 'the network this box is on is restricted',
+  INELIGIBLE_ACCOUNT: 'Google marks this account as not eligible',
+  UNSUPPORTED_CLIENT: 'Google no longer serves the client metro presents; nothing on this box can fix that',
+};
+
+function refuseIneligible(load: Record<string, unknown>): void {
+  if (isRecord(load.currentTier) || !Array.isArray(load.ineligibleTiers)) return;
+  const tiers = load.ineligibleTiers.filter(isRecord);
+  if (tiers.length === 0) return;
+  const validation = tiers.find((t) => t.reasonCode === 'VALIDATION_REQUIRED' && nonEmpty(t.validationUrl) !== null);
+  if (validation !== undefined) throw new GeminiAuthError(`Google asks you to validate the account first: open ${nonEmpty(validation.validationUrl) ?? ''} and then connect again`);
+  const said = tiers.map((t) => `${nonEmpty(t.reasonMessage) ?? 'not eligible'} [${nonEmpty(t.reasonCode) ?? 'UNKNOWN'}: ${REASONS[nonEmpty(t.reasonCode) ?? ''] ?? 'no known reason'}]`);
+  throw new GeminiAuthError(said.join('; '));
+}
+
+const NO_PROJECT = 'this account holds a Code Assist licence but Google named no project for it: enter the id of the Google Cloud project that carries the licence and connect again';
+
+function tierToOnboard(load: Record<string, unknown>): { id: string; name: string | null } {
+  const allowed = Array.isArray(load.allowedTiers) ? load.allowedTiers.filter(isRecord) : [];
+  const chosen = allowed.find((t) => t.isDefault === true);
+  return { id: nonEmpty(chosen?.id) ?? FREE_TIER, name: nonEmpty(chosen?.name) };
+}
+
+const summary = (load: Record<string, unknown>): Record<string, unknown> => ({
+  current: isRecord(load.currentTier) ? nonEmpty(load.currentTier.id) : null,
+  paid: isRecord(load.paidTier) ? nonEmpty(load.paidTier.id) : null,
+  allowed: Array.isArray(load.allowedTiers) ? load.allowedTiers.filter(isRecord).map((t) => `${nonEmpty(t.id) ?? '?'}${t.isDefault === true ? '*' : ''}`) : [],
+  ineligible: Array.isArray(load.ineligibleTiers) ? load.ineligibleTiers.filter(isRecord).map((t) => `${nonEmpty(t.tierId) ?? '?'}:${nonEmpty(t.reasonCode) ?? '?'}`) : [],
+  project: nonEmpty(load.cloudaicompanionProject),
+});
+
+function onboardBody(load: Record<string, unknown>, project: string | null): { body: Record<string, unknown>; name: string | null } {
+  const wanted = tierToOnboard(load);
+  const paid = wanted.id !== FREE_TIER && project !== null;
+  return { body: { tierId: wanted.id, metadata: clientMetadata(paid ? project : null) }, name: wanted.name ?? wanted.id };
+}
+
+const NO_ASSIGNMENT = 'Google did not assign a Code Assist project to this account; enter the id of the Google Cloud project that carries your licence and connect again';
+
+const withProject = (project: string | null): Record<string, unknown> => (project === null ? {} : { cloudaicompanionProject: project });
+
+const assignedProject = (op: Record<string, unknown>): string | null => {
+  const response = isRecord(op.response) ? op.response : {};
+  return isRecord(response.cloudaicompanionProject) ? nonEmpty(response.cloudaicompanionProject.id) : null;
+};
+
+async function onboardNew(load: Record<string, unknown>, tokens: GeminiTokens, project: string | null, bases: string[], fetchImpl: typeof fetch): Promise<Onboarded> {
+  const { body, name } = onboardBody(load, project);
+  const first = await call(bases, 'onboardUser', tokens.accessToken, body, fetchImpl);
+  const op = await waitOperation(bases[0] ?? '', tokens.accessToken, first, fetchImpl);
+  const assigned = assignedProject(op) ?? project;
+  if (assigned === null) throw new GeminiAuthError(NO_ASSIGNMENT);
+  return { project: assigned, tier: name };
+}
+
+export async function onboard(tokens: GeminiTokens, project: string | null = null, base?: Bases, fetchImpl: typeof fetch = fetch): Promise<Onboarded> {
+  const bases = setupBases(base);
+  const asked = { metadata: clientMetadata(project), mode: 1, ...withProject(project) };
+  const load = await call(bases, 'loadCodeAssist', tokens.accessToken, asked, fetchImpl);
+  log.info(summary(load), 'gemini: Code Assist answered loadCodeAssist');
+  refuseIneligible(load);
+  if (!isRecord(load.currentTier)) return onboardNew(load, tokens, project, [...bases].reverse(), fetchImpl);
+  const known = nonEmpty(load.cloudaicompanionProject) ?? project;
+  if (known === null) throw new GeminiAuthError(NO_PROJECT);
+  const tier = tierOf(load);
+  return { project: known, tier: tier.name ?? tier.id };
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/gemini-stream.ts

@@ -0,0 +1,139 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { errorFrame } from './forward.js';
+import { frame, messageEnd, messageStart, type Usage } from './frames.js';
+import { encodeSignature, newCallId, rememberSignature } from './gemini-translate.js';
+import { stringOf } from '@metro-labs/http/api-http';
+
+type Item = Record<string, unknown>;
+
+interface Open {
+  index: number;
+  kind: 'text' | 'thinking';
+  signature: string | null;
+}
+
+const num = (value: unknown): number => (typeof value === 'number' ? value : 0);
+
+const STOP_OF: Record<string, string> = { STOP: 'end_turn', MAX_TOKENS: 'max_tokens' };
+const REFUSALS = new Set(['SAFETY', 'RECITATION', 'BLOCKLIST', 'PROHIBITED_CONTENT', 'SPII', 'MALFORMED_FUNCTION_CALL']);
+
+function usageOf(meta: Item): Usage {
+  const cached = num(meta.cachedContentTokenCount);
+  return {
+    input_tokens: Math.max(0, num(meta.promptTokenCount) - cached),
+    output_tokens: num(meta.candidatesTokenCount) + num(meta.thoughtsTokenCount),
+    cache_read_input_tokens: cached,
+  };
+}
+
+export class GeminiStreamTranslator {
+  private next = 0;
+  private open: Open | null = null;
+  private started = false;
+  private done = false;
+  private toolCalls = 0;
+  private usage: Usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 };
+  private stop = 'end_turn';
+  private finishedBy: string | null = null;
+  private refusal: string | null = null;
+  private readonly model: string;
+  private readonly restore: (name: string) => string;
+
+  constructor(model: string, restore: (name: string) => string = (name) => name) {
+    this.model = model;
+    this.restore = restore;
+  }
+
+  get finished(): boolean {
+    return this.done;
+  }
+
+  private start(): string {
+    if (this.started) return '';
+    this.started = true;
+    return messageStart('msg_gemini', this.model);
+  }
+
+  private closeOpen(): string {
+    const block = this.open;
+    if (block === null) return '';
+    this.open = null;
+    const signature = block.kind === 'thinking' ? frame('content_block_delta', { type: 'content_block_delta', index: block.index, delta: { type: 'signature_delta', signature: encodeSignature(block.signature ?? '') } }) : '';
+    return signature + frame('content_block_stop', { type: 'content_block_stop', index: block.index });
+  }
+
+  private ensure(kind: Open['kind']): string {
+    if (this.open?.kind === kind) return '';
+    const closed = this.closeOpen();
+    this.open = { index: this.next, kind, signature: null };
+    this.next += 1;
+    const content = kind === 'text' ? { type: 'text', text: '' } : { type: 'thinking', thinking: '' };
+    return closed + frame('content_block_start', { type: 'content_block_start', index: this.open.index, content_block: content });
+  }
+
+  private textPart(part: Item): string {
+    const kind = part.thought === true ? 'thinking' : 'text';
+    const text = stringOf(part.text);
+    let out = this.ensure(kind);
+    const block = this.open;
+    if (block !== null && stringOf(part.thoughtSignature) !== '') block.signature = stringOf(part.thoughtSignature);
+    if (text === '') return out;
+    const delta = kind === 'text' ? { type: 'text_delta', text } : { type: 'thinking_delta', thinking: text };
+    out += frame('content_block_delta', { type: 'content_block_delta', index: block?.index ?? 0, delta });
+    return out;
+  }
+
+  private callPart(call: Item, signature: string): string {
+    this.toolCalls += 1;
+    const id = stringOf(call.id) || newCallId();
+    if (signature !== '') rememberSignature(id, signature);
+    const index = this.next;
+    this.next += 1;
+    return (
+      this.closeOpen() +
+      frame('content_block_start', { type: 'content_block_start', index, content_block: { type: 'tool_use', id, name: this.restore(stringOf(call.name)), input: {} } }) +
+      frame('content_block_delta', { type: 'content_block_delta', index, delta: { type: 'input_json_delta', partial_json: JSON.stringify(isRecord(call.args) ? call.args : {}) } }) +
+      frame('content_block_stop', { type: 'content_block_stop', index })
+    );
+  }
+
+  private part(part: Item): string {
+    if (isRecord(part.functionCall)) return this.callPart(part.functionCall, stringOf(part.thoughtSignature));
+    if (typeof part.text === 'string') return this.textPart(part);
+    return '';
+  }
+
+  private candidate(candidate: Item): string {
+    const content = isRecord(candidate.content) ? candidate.content : {};
+    const parts = Array.isArray(content.parts) ? content.parts.filter(isRecord) : [];
+    const out = parts.map((part) => this.part(part)).join('');
+    const finish = stringOf(candidate.finishReason);
+    if (finish !== '') this.finishedBy = finish;
+    const stop = STOP_OF[finish];
+    if (stop !== undefined) this.stop = stop;
+    else if (REFUSALS.has(finish)) this.refusal = `Gemini stopped the answer (${finish})`;
+    return out;
+  }
+
+  push(data: Item): string {
+    if (this.done) return '';
+    const response = isRecord(data.response) ? data.response : data;
+    const out = this.start();
+    if (isRecord(response.usageMetadata)) this.usage = usageOf(response.usageMetadata);
+    const candidate = Array.isArray(response.candidates) ? response.candidates.find(isRecord) : undefined;
+    if (candidate !== undefined) return out + this.candidate(candidate);
+    const feedback = isRecord(response.promptFeedback) ? stringOf(response.promptFeedback.blockReason) : '';
+    if (feedback !== '') this.refusal = `Gemini blocked the prompt (${feedback})`;
+    return out;
+  }
+
+  close(error?: string): string {
+    if (this.done) return '';
+    this.done = true;
+    const out = this.start() + this.closeOpen();
+    const unfinished = this.finishedBy === null && this.refusal === null ? 'Gemini ended the stream before completing the response' : null;
+    const failure = error ?? this.refusal ?? unfinished;
+    if (failure !== null) return out + errorFrame('api_error', failure);
+    return out + messageEnd(this.toolCalls > 0 ? 'tool_use' : this.stop, this.usage);
+  }
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/gemini-translate.ts

@@ -0,0 +1,224 @@
+import { randomBytes } from 'node:crypto';
+import { isRecord } from '@metro-labs/core/is-record';
+import { ToolNames } from './codex-translate.js';
+import { CLIENT_NAME, requestId, SYSTEM_PREFIX } from './gemini-client.js';
+import { cappedEffort, effortToApply } from './effort.js';
+import { resultText } from './text.js';
+import { stringOf } from '@metro-labs/http/api-http';
+
+type Item = Record<string, unknown>;
+
+const SIGNATURE_PREFIX = 'metro-gemini:';
+export const SKIP_SIGNATURE = 'skip_thought_signature_validator';
+const SCHEMA_KEEP = new Set([
+  'type',
+  'description',
+  'nullable',
+  'enum',
+  'required',
+  'minItems',
+  'maxItems',
+  'minProperties',
+  'maxProperties',
+  'minLength',
+  'maxLength',
+  'pattern',
+  'minimum',
+  'maximum',
+  'propertyOrdering',
+]);
+const SCHEMA_LISTS = new Set(['anyOf', 'oneOf']);
+const SIGNATURES_MAX = 2000;
+const MAX_OUTPUT_TOKENS = 16384;
+
+
+const callSignatures = new Map<string, string>();
+
+export function rememberSignature(id: string, signature: string): void {
+  callSignatures.set(id, signature);
+  if (callSignatures.size > SIGNATURES_MAX) {
+    const first = callSignatures.keys().next().value;
+    if (first !== undefined) callSignatures.delete(first);
+  }
+}
+
+export const newCallId = (): string => `toolu_gm_${randomBytes(12).toString('base64url')}`;
+
+export const encodeSignature = (signature: string): string => `${SIGNATURE_PREFIX}${Buffer.from(signature).toString('base64url')}`;
+
+export function decodeSignature(signature: unknown): string | null {
+  if (typeof signature !== 'string' || !signature.startsWith(SIGNATURE_PREFIX)) return null;
+  const raw = Buffer.from(signature.slice(SIGNATURE_PREFIX.length), 'base64url').toString('utf8');
+  return raw === '' ? null : raw;
+}
+
+export function systemText(system: unknown): string {
+  if (typeof system === 'string') return system.trim();
+  if (!Array.isArray(system)) return '';
+  return system
+    .filter(isRecord)
+    .map((block) => stringOf(block.text))
+    .filter((t) => t !== '')
+    .join('\n\n')
+    .trim();
+}
+
+function userPart(block: Item): Item | null {
+  if (block.type === 'text') return { text: stringOf(block.text) };
+  if (block.type === 'image' && isRecord(block.source) && block.source.type === 'base64')
+    return { inlineData: { mimeType: stringOf(block.source.media_type), data: stringOf(block.source.data) } };
+  return null;
+}
+
+function userParts(content: unknown, calls: Map<string, string>): Item[] {
+  if (typeof content === 'string') return content === '' ? [] : [{ text: content }];
+  if (!Array.isArray(content)) return [];
+  const out: Item[] = [];
+  for (const block of content.filter(isRecord)) {
+    if (block.type === 'tool_result') {
+      const id = stringOf(block.tool_use_id);
+      out.push({ functionResponse: { id, name: calls.get(id) ?? 'tool', response: { result: resultText(block) } } });
+      continue;
+    }
+    const part = userPart(block);
+    if (part !== null) out.push(part);
+  }
+  return out;
+}
+
+function callPart(block: Item, names: ToolNames, calls: Map<string, string>): Item {
+  const id = stringOf(block.id);
+  const name = names.alias(stringOf(block.name));
+  calls.set(id, name);
+  return { functionCall: { id, name, args: isRecord(block.input) ? block.input : {} }, thoughtSignature: callSignatures.get(id) ?? SKIP_SIGNATURE };
+}
+
+function assistantPart(block: Item, names: ToolNames, calls: Map<string, string>): Item | null {
+  if (block.type === 'text') return { text: stringOf(block.text) };
+  if (block.type === 'tool_use') return callPart(block, names, calls);
+  if (block.type !== 'thinking') return null;
+  const signature = decodeSignature(block.signature);
+  return signature === null ? null : { text: stringOf(block.thinking) || ' ', thought: true, thoughtSignature: signature };
+}
+
+function assistantParts(content: unknown, names: ToolNames, calls: Map<string, string>): Item[] {
+  if (typeof content === 'string') return content === '' ? [] : [{ text: content }];
+  if (!Array.isArray(content)) return [];
+  const out: Item[] = [];
+  for (const block of content.filter(isRecord)) {
+    const part = assistantPart(block, names, calls);
+    if (part !== null) out.push(part);
+  }
+  return out;
+}
+
+function appendTurn(out: Item[], role: string, parts: Item[]): void {
+  if (parts.length === 0) return;
+  const last = out.at(-1);
+  const held = last?.role === role && Array.isArray(last.parts) ? (last.parts as Item[]) : null;
+  if (held !== null) held.push(...parts);
+  else out.push({ role, parts });
+}
+
+export function contentsOf(messages: unknown, names = new ToolNames()): Item[] {
+  const out: Item[] = [];
+  if (!Array.isArray(messages)) return out;
+  const calls = new Map<string, string>();
+  for (const message of messages.filter(isRecord)) {
+    const model = message.role === 'assistant';
+    appendTurn(out, model ? 'model' : 'user', model ? assistantParts(message.content, names, calls) : userParts(message.content, calls));
+  }
+  return out;
+}
+
+function schemaType(value: unknown, out: Item): void {
+  if (!Array.isArray(value)) {
+    out.type = value;
+    return;
+  }
+  const kinds = value.filter((k) => k !== 'null');
+  if (kinds.length !== value.length) out.nullable = true;
+  if (kinds.length > 0) out.type = kinds[0];
+}
+
+function schemaField(key: string, value: unknown, out: Item): void {
+  if (key === 'type') schemaType(value, out);
+  else if (key === 'const') out.enum = [value];
+  else if (key === 'items') out.items = cleanSchema(value);
+  else if (key === 'properties' && isRecord(value)) out.properties = Object.fromEntries(Object.entries(value).map(([name, v]) => [name, cleanSchema(v)]));
+  else if (SCHEMA_LISTS.has(key) && Array.isArray(value)) out.anyOf = value.map(cleanSchema);
+  else if (SCHEMA_KEEP.has(key)) out[key] = value;
+}
+
+export function cleanSchema(schema: unknown): Item {
+  if (!isRecord(schema)) return {};
+  const out: Item = {};
+  for (const [key, value] of Object.entries(schema)) schemaField(key, value, out);
+  return out;
+}
+
+export function toolDeclarations(tools: unknown, names = new ToolNames()): Item[] {
+  if (!Array.isArray(tools)) return [];
+  return tools
+    .filter(isRecord)
+    .filter((tool) => typeof tool.name === 'string' && (tool.type === undefined || tool.type === 'custom'))
+    .map((tool) => ({
+      name: names.alias(stringOf(tool.name)),
+      description: stringOf(tool.description),
+      parameters: cleanSchema(isRecord(tool.input_schema) ? tool.input_schema : { type: 'object', properties: {} }),
+    }));
+}
+
+function toolConfig(choice: unknown, names: ToolNames): Item | null {
+  if (!isRecord(choice)) return null;
+  if (choice.type === 'any') return { functionCallingConfig: { mode: 'ANY' } };
+  if (choice.type === 'none') return { functionCallingConfig: { mode: 'NONE' } };
+  if (choice.type === 'tool') return { functionCallingConfig: { mode: 'ANY', allowedFunctionNames: [names.alias(stringOf(choice.name))] } };
+  return null;
+}
+
+function generationConfig(body: Item): Item {
+  const out: Item = {};
+  if (typeof body.max_tokens === 'number') out.maxOutputTokens = Math.min(body.max_tokens, MAX_OUTPUT_TOKENS);
+  if (typeof body.temperature === 'number') out.temperature = body.temperature;
+  if (typeof body.top_p === 'number') out.topP = body.top_p;
+  if (isRecord(body.thinking) && body.thinking.type === 'enabled') out.thinkingConfig = { includeThoughts: true };
+  const effort = effortToApply(body);
+  if (effort !== null) out.thinkingLevel = cappedEffort(effort);
+  return out;
+}
+
+export interface GeminiRequest {
+  model: string;
+  project: string;
+  userAgent: string;
+  requestType: string;
+  requestId: string;
+  request: Item;
+}
+
+const systemParts = (system: string): Item[] => [
+  { text: SYSTEM_PREFIX },
+  { text: `Please ignore the following [ignore]${SYSTEM_PREFIX}[/ignore]` },
+  ...(system === '' ? [] : [{ text: system }]),
+];
+
+export function toGeminiRequest(body: Item, model: string, project: string, promptId: string, names = new ToolNames()): GeminiRequest {
+  const declarations = toolDeclarations(body.tools, names);
+  const config = toolConfig(body.tool_choice, names);
+  return {
+    model,
+    project,
+    userAgent: CLIENT_NAME,
+    requestType: 'agent',
+    requestId: requestId(),
+    request: {
+      contents: contentsOf(body.messages, names),
+      systemInstruction: { role: 'user', parts: systemParts(systemText(body.system)) },
+      ...(declarations.length === 0 ? {} : { tools: [{ functionDeclarations: declarations }] }),
+      ...(config === null ? {} : { toolConfig: config }),
+      generationConfig: generationConfig(body),
+      sessionId: promptId,
+    },
+  };
+}