@stage-labs/metro 0.1.0-beta.2 → 0.1.0-beta.200

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 './text.js';
+
+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,223 @@
+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, stringOf } from './text.js';
+
+type Item = Record<string, unknown>;
+
+export 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,
+    },
+  };
+}

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

@@ -0,0 +1,208 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg, log } from '@metro-labs/core/log';
+import { refreshTokens, tokensStale, type GeminiTokens } from './gemini-auth.js';
+import { API, clientHeaders, generateBases, machineSessionId, type Bases } from './gemini-client.js';
+import { GeminiStreamTranslator } from './gemini-stream.js';
+import { toGeminiRequest } from './gemini-translate.js';
+import { ToolNames } from './codex-translate.js';
+import { GatewayError, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
+import type { Connection } from './model-config.js';
+import { answerWhole, currentOf, errorKind, reach, refreshed, relayTranslated, sessionHeader, type TokenSource, type TokenState } from './subscription.js';
+import { effortToApply, withoutEffort } from './effort.js';
+
+export interface GeminiDeps {
+  base?: Bases;
+  tokenBase?: string;
+  fetchImpl?: typeof fetch;
+  save: (id: string, tokens: GeminiTokens) => void;
+}
+
+export type GeminiState = TokenState<GeminiTokens>;
+
+export const sharedGeminiState: GeminiState = new Map();
+
+const sourceOf = (deps: GeminiDeps): TokenSource<GeminiTokens> => ({
+  label: 'Google',
+  stale: (tokens) => tokensStale(tokens),
+  refresh: (tokens) => refreshTokens(tokens, deps.tokenBase, deps.fetchImpl),
+  save: deps.save,
+});
+
+export const currentGeminiTokens = (conn: Connection, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> =>
+  currentOf(state, conn.id, conn.gemini, sourceOf(deps), 'Gemini is not connected: sign in with Google on the Model page.');
+
+interface Call {
+  body: Record<string, unknown>;
+  model: string;
+  promptId: string;
+  watch: Watch;
+  deps: GeminiDeps;
+  names: ToolNames;
+  conn: Connection;
+}
+
+const headersFor = (token: string, stream: boolean): Record<string, string> => ({
+  authorization: `Bearer ${token}`,
+  'content-type': 'application/json',
+  ...clientHeaders(),
+  'x-machine-session-id': machineSessionId(),
+  ...(stream ? { accept: 'text/event-stream' } : {}),
+});
+
+async function sendTo(base: string, call: Call, tokens: GeminiTokens, stream: boolean): Promise<Response> {
+  const request = toGeminiRequest(call.body, call.model, tokens.project, call.promptId, call.names);
+  const method = stream ? 'streamGenerateContent?alt=sse' : 'generateContent';
+  return (call.deps.fetchImpl ?? fetch)(`${base}/${API}:${method}`, {
+    method: 'POST',
+    headers: headersFor(tokens.accessToken, stream),
+    body: JSON.stringify(request),
+    signal: call.watch.signal,
+    redirect: 'manual',
+  });
+}
+
+async function send(call: Call, tokens: GeminiTokens, stream: boolean): Promise<Response> {
+  const bases = generateBases(call.deps.base);
+  let last: Response | null = null;
+  for (const base of bases) {
+    if (last !== null) await last.body?.cancel();
+    try {
+      last = await sendTo(base, call, tokens, stream);
+    } catch (err) {
+      if (base === bases.at(-1) || call.watch.signal.aborted) throw err;
+      continue;
+    }
+    if (last.status < 500 && last.status !== 429) return last;
+  }
+  if (last === null) throw new GatewayError(502, 'api_error', 'no Code Assist endpoint to call');
+  return last;
+}
+
+const REFUSAL_LOG_MAX = 2000;
+
+const detailText = (detail: Record<string, unknown>): string[] => {
+  const out: string[] = [];
+  if (typeof detail.reason === 'string') out.push(detail.reason);
+  if (isRecord(detail.metadata)) out.push(...Object.entries(detail.metadata).map(([k, v]) => `${k}=${String(v)}`));
+  if (typeof detail.retryDelay === 'string') out.push(`retry after ${detail.retryDelay}`);
+  if (Array.isArray(detail.violations))
+    out.push(...detail.violations.filter(isRecord).map((v) => [v.subject, v.description].filter((x) => typeof x === 'string').join(': ')));
+  return out.filter((x) => x !== '');
+};
+
+export function refusalMessage(text: string, status: number): string {
+  const message = upstreamMessage(text, `Gemini answered ${String(status)}`);
+  let details: unknown = null;
+  try {
+    const parsed: unknown = JSON.parse(text);
+    details = isRecord(parsed) && isRecord(parsed.error) ? parsed.error.details : null;
+  } catch {
+    return message;
+  }
+  const notes = Array.isArray(details) ? details.filter(isRecord).flatMap(detailText) : [];
+  return notes.length === 0 ? message : `${message} (${notes.join('; ')})`;
+}
+
+const reachWith = (call: Call, state: GeminiState, stream: boolean): Promise<Response> =>
+  reach(
+    () => currentGeminiTokens(call.conn, call.deps, state),
+    (tokens) => refreshed(state, call.conn.id, tokens, sourceOf(call.deps)),
+    (tokens) => send(call, tokens, stream),
+  );
+
+export interface GeminiModel {
+  id: string;
+  name: string;
+  remaining: number | null;
+  resetAt: string | null;
+}
+
+const modelOf = (id: string, raw: unknown): GeminiModel => {
+  const entry = isRecord(raw) ? raw : {};
+  const quota = isRecord(entry.quotaInfo) ? entry.quotaInfo : null;
+  const fraction = quota !== null && typeof quota.remainingFraction === 'number' ? quota.remainingFraction : null;
+  const resetAt = quota !== null && typeof quota.resetTime === 'string' ? quota.resetTime : null;
+  return { id, name: typeof entry.displayName === 'string' ? entry.displayName : id, remaining: fraction ?? (resetAt === null ? null : 0), resetAt };
+};
+
+export async function listGeminiModels(tokens: GeminiTokens, deps: GeminiDeps): Promise<GeminiModel[]> {
+  let last = 'no Code Assist endpoint to call';
+  for (const base of generateBases(deps.base)) {
+    try {
+      const res = await (deps.fetchImpl ?? fetch)(`${base}/${API}:fetchAvailableModels`, {
+        method: 'POST',
+        headers: headersFor(tokens.accessToken, false),
+        body: JSON.stringify({ project: tokens.project }),
+        signal: AbortSignal.timeout(30_000),
+      });
+      const body: unknown = await res.json().catch(() => null);
+      if (!res.ok) {
+        last = upstreamMessage(JSON.stringify(body), `Google answered ${String(res.status)}`);
+        continue;
+      }
+      const models = isRecord(body) && isRecord(body.models) ? body.models : {};
+      return Object.entries(models)
+        .filter(([id]) => id.startsWith('gemini'))
+        .map(([id, raw]) => modelOf(id, raw));
+    } catch (err) {
+      last = errMsg(err);
+    }
+  }
+  throw new GatewayError(502, 'api_error', `could not list the Gemini models: ${last}`);
+}
+
+const parseData = (raw: string): Record<string, unknown> | null => {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+
+const NAMES_THINKING = /thinking|thought/i;
+
+function refuse(res: ServerResponse, model: string, status: number, text: string): void {
+  log.warn({ provider: 'gemini', model, status, body: text.slice(0, REFUSAL_LOG_MAX) }, 'gateway: the provider refused the request');
+  sendError(res, providerStatus(status), errorKind(status), refusalMessage(text, status));
+}
+
+export async function geminiMessages(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  model: string,
+  conn: Connection,
+  deps: GeminiDeps,
+  state: GeminiState,
+  watch: Watch,
+): Promise<void> {
+  const stream = body.stream === true;
+  let call: Call = { body, model, promptId: sessionHeader(req) || 'metro', watch, deps, names: new ToolNames(), conn };
+  let upstream = await reachWith(call, state, stream);
+  if (upstream.status === 400 && effortToApply(body) !== null) {
+    const text = await upstream.text();
+    if (!NAMES_THINKING.test(text)) {
+      refuse(res, model, 400, text);
+      return;
+    }
+    log.warn({ provider: 'gemini', model }, 'gateway: Gemini refused the thinking level, so metro asked again without it');
+    call = { ...call, body: withoutEffort(body) };
+    upstream = await reachWith(call, state, stream);
+  }
+  if (!upstream.ok) {
+    refuse(res, model, upstream.status, await upstream.text());
+    return;
+  }
+  const translator = new GeminiStreamTranslator(model, (name) => call.names.restore(name));
+  if (stream) {
+    await relayTranslated(upstream, res, watch, conn.id, translator, (raw) => {
+      const data = parseData(raw.data);
+      return data === null ? '' : translator.push(data);
+    });
+    return;
+  }
+  const data = parseData(await upstream.text());
+  answerWhole(res, (data === null ? '' : translator.push(data)) + translator.close(), conn.id);
+}