@stage-labs/metro 0.1.0-beta.324 → 0.1.0-beta.326

package/runtime/node_modules/@metro-labs/gmail/src/accounts.ts

@@ -1,3 +1,4 @@
+import { errMsg } from '@metro-labs/core/log';
 import { makeAccountStore, resolveAccountId, type Die } from '@metro-labs/core/stations/account-store';
 import { threadOfLine } from '@metro-labs/core/stations/mail';
 import { TokenKeeper, type FetchLike } from '@metro-labs/core/stations/oauth';
@@ -43,7 +44,7 @@ export const { loadAccounts } = makeAccountStore<AccountConfig>({
 });
 
 const signedOut = (err: unknown): never => {
-  throw new TrainError('gmail_signed_out', err instanceof Error ? err.message : String(err), { retryable: false });
+  throw new TrainError('gmail_signed_out', errMsg(err), { retryable: false });
 };
 
 export class Account {
@@ -63,10 +64,9 @@ export class Account {
     const client = { clientId: cfg.clientId ?? '', clientSecret: cfg.clientSecret ?? '' };
     this.keeper = new TokenKeeper(this.state, async (refreshToken) => {
       checkManagedBinding(cfg);
-      const tokens = await (cfg.managed === true
+      return (cfg.managed === true
         ? renewManaged(refreshToken, this.state.refreshGrant ?? '', cfg.managedHost ?? '', this.fetchImpl)
         : refreshTokens(client, refreshToken, this.fetchImpl, Date.now(), cfg.sendEnabled)).catch(signedOut);
-      return tokens;
     }, () => {
       this.save();
     });

package/runtime/node_modules/@metro-labs/gmail/src/auth.ts

@@ -1,3 +1,5 @@
+import { errMsg } from '@metro-labs/core/log';
+import { str } from '@metro-labs/core/stations/mail';
 import { postForm, SignInError, tokensOf, type FetchLike, type OAuthBody, type Tokens } from '@metro-labs/core/stations/oauth';
 import { apiBase, authorizeBase, redirectUri, scopesFor, tokenUrl } from './config.js';
 
@@ -15,11 +17,9 @@ export interface GmailClient {
 
 const CLIENT_ID_RE = /^[\w.-]+\.apps\.googleusercontent\.com$/;
 
-const text = (v: unknown): string => (typeof v === 'string' ? v.trim() : '');
-
 export function clientOf(rawId: unknown, rawSecret: unknown): GmailClient {
-  const clientId = text(rawId);
-  const clientSecret = text(rawSecret);
+  const clientId = str(rawId);
+  const clientSecret = str(rawSecret);
   if (!CLIENT_ID_RE.test(clientId))
     throw new SignInError('Paste the client ID of your Google OAuth client. It ends with .apps.googleusercontent.com.');
   if (clientSecret === '' || /\s/.test(clientSecret)) throw new SignInError('Paste the client secret of your Google OAuth client.');
@@ -27,13 +27,13 @@ export function clientOf(rawId: unknown, rawSecret: unknown): GmailClient {
 }
 
 export function failureOf(body: OAuthBody): string {
-  const error = text(body.error);
+  const error = str(body.error);
   if (error === 'access_denied') return 'The sign-in was declined, so nothing was connected.';
   if (error === 'invalid_client' || error === 'unauthorized_client')
     return 'Google does not accept this client ID and secret. Check both on the Clients page of your Google Cloud project.';
   if (error === 'redirect_uri_mismatch') return `Your Google OAuth client must list ${redirectUri()} as an authorized redirect URI.`;
   if (error === 'admin_policy_enforced') return 'Your Google Workspace administrator blocks this app. Trust it in the Admin console under API controls, then start again.';
-  const detail = text(body.error_description);
+  const detail = str(body.error_description);
   return detail === '' ? `Google refused the sign-in (${error === '' ? 'no reason given' : error}).` : `Google refused the sign-in: ${detail}`;
 }
 
@@ -101,14 +101,14 @@ export async function verifyMailbox(accessToken: string, fetchImpl: FetchLike, w
       headers: { authorization: `Bearer ${accessToken}`, accept: 'application/json' },
     });
   } catch (err) {
-    throw new SignInError(`Metro could not reach Gmail: ${err instanceof Error ? err.message : String(err)}`);
+    throw new SignInError(`Metro could not reach Gmail: ${errMsg(err)}`);
   }
   if (!res.ok) {
     const hint = res.status === 403 ? ' Check that the Gmail API is enabled in your Google Cloud project.' : '';
     throw new SignInError(`Gmail refused the new sign-in (${await googleMessage(res)}), so nothing was connected.${hint}`);
   }
   const body = (await res.json().catch(() => ({}))) as Record<string, unknown>;
-  const email = text(body.emailAddress).toLowerCase();
+  const email = str(body.emailAddress).toLowerCase();
   if (email === '') throw new SignInError('Gmail did not say which mailbox this is, so nothing was connected.');
   if (wanted !== null && wanted !== email) throw new SignInError(wrongMailbox(email, wanted));
   return email;

package/runtime/node_modules/@metro-labs/gmail/src/managed.ts

@@ -1,3 +1,4 @@
+import { isRecord } from '@metro-labs/core/is-record';
 import { SignInError, type FetchLike, type Tokens } from '@metro-labs/core/stations/oauth';
 
 const BASE = 'https://api.metro.box/api/gmail';
@@ -25,8 +26,8 @@ export async function managedRequest(path: 'start' | 'exchange' | 'cancel' | 're
     throw new SignInError(`Metro could not complete managed Gmail sign-in. ${retry}`);
   }
   const value: unknown = await response.json().catch(() => null);
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) throw new SignInError('Metro returned an invalid Gmail answer.');
-  return value as Record<string, unknown>;
+  if (!isRecord(value)) throw new SignInError('Metro returned an invalid Gmail answer.');
+  return value;
 }
 
 export function managedTokens(value: Record<string, unknown>): ManagedTokens {

package/runtime/node_modules/@metro-labs/http/src/agent-signature.ts

@@ -1,7 +1,7 @@
 import { createHash, createPublicKey, randomBytes, sign, verify, type KeyObject } from 'node:crypto';
 import { strongEd25519 } from './ed25519.js';
 
-export const AGENT_SCHEME = 'MetroAgent';
+const AGENT_SCHEME = 'MetroAgent';
 export const AGENT_CLOCK_SKEW_MS = 5 * 60_000;
 
 const VERSION = 'metro-agent-request/v1';

package/runtime/node_modules/@metro-labs/http/src/api-http.ts

@@ -1,10 +1,11 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { ApiError } from './api-error.js';
+import { isRecord } from '@metro-labs/core/is-record';
 import { errMsg, log } from '@metro-labs/core/log';
 
 const BODY_MAX = 4 * 1024;
 
-export type Role = 'admin' | 'member';
+type Role = 'admin' | 'member';
 
 export interface ApiSession {
   subject: string;
@@ -151,9 +152,7 @@ export function sessionRoute(
 }
 
 export function bodyField(body: unknown, key: string): unknown {
-  return typeof body === 'object' && body !== null && !Array.isArray(body)
-    ? (body as Record<string, unknown>)[key]
-    : undefined;
+  return isRecord(body) ? body[key] : undefined;
 }
 
 export const stringOf = (value: unknown): string => (typeof value === 'string' ? value : '');

package/runtime/node_modules/@metro-labs/http/src/connector-discovery.ts

@@ -1,10 +1,3 @@
-import { isRecord } from '@metro-labs/core/is-record';
-import type { FetchLike } from '@metro-labs/core/stations/oauth';
-import { stringOf } from './api-http.js';
-import { parseConnectorUrl, refused } from './connector-url.js';
-
-const DISCOVERY_TIMEOUT_MS = 10_000;
-
 export interface OAuthServer {
   issuer: string;
   authorizationEndpoint: string;
@@ -14,30 +7,6 @@ export interface OAuthServer {
   scopes: string[];
 }
 
-interface ResourceMetadata {
-  issuer: URL;
-  scopes: string[];
-}
-
-async function getJson(url: URL, fetchImpl: FetchLike): Promise<Record<string, unknown> | null> {
-  let res: Response;
-  try {
-    res = await fetchImpl(url.toString(), {
-      redirect: 'manual',
-      signal: AbortSignal.timeout(DISCOVERY_TIMEOUT_MS),
-      headers: { accept: 'application/json' },
-    });
-  } catch {
-    return null;
-  }
-  if (!res.ok) {
-    await res.body?.cancel().catch(() => undefined);
-    return null;
-  }
-  const body: unknown = await res.json().catch(() => null);
-  return isRecord(body) ? body : null;
-}
-
 function wellKnown(base: URL, suffix: string): URL {
   const url = new URL(base.toString());
   url.pathname = `/.well-known/${suffix}`;
@@ -56,77 +25,6 @@ export function resourceMetadataUrls(resource: URL): URL[] {
   return urls;
 }
 
-export async function advertisesOAuth(resource: URL, fetchImpl: FetchLike = fetch): Promise<boolean> {
-  for (const candidate of resourceMetadataUrls(resource)) {
-    const body = await getJson(candidate, fetchImpl);
-    const servers: unknown = body?.authorization_servers;
-    const first: unknown = Array.isArray(servers) ? servers[0] : undefined;
-    if (typeof first === 'string' && first !== '') return true;
-  }
-  return false;
-}
-
-function scopesOf(body: Record<string, unknown> | null): string[] {
-  const raw: unknown = body?.scopes_supported;
-  if (!Array.isArray(raw)) return [];
-  const out: string[] = [];
-  for (const entry of raw) {
-    const scope = stringOf(entry).trim();
-    if (scope !== '' && !/\s/.test(scope) && !out.includes(scope)) out.push(scope);
-  }
-  return out;
-}
-
-async function resourceMetadata(resource: URL, fetchImpl: FetchLike): Promise<ResourceMetadata> {
-  for (const candidate of resourceMetadataUrls(resource)) {
-    const body = await getJson(candidate, fetchImpl);
-    const servers: unknown = body?.authorization_servers;
-    const first: unknown = Array.isArray(servers) ? servers[0] : undefined;
-    if (typeof first === 'string' && first !== '')
-      return { issuer: parseConnectorUrl(first), scopes: scopesOf(body) };
-  }
-  return { issuer: parseConnectorUrl(resource.origin), scopes: [] };
-}
-
-const webAddress = (text: string): boolean => {
-  try {
-    parseConnectorUrl(text);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-function endpointOf(raw: unknown, issuer: URL): string {
-  const text = stringOf(raw);
-  if (text !== '' && !webAddress(text)) throw refused(`${issuer.hostname} advertises a sign-in address Metro will not open.`);
-  return text;
-}
-
-function toServer(
-  body: Record<string, unknown>,
-  issuer: URL,
-  scopes: string[],
-): OAuthServer {
-  const authorizationEndpoint = endpointOf(body.authorization_endpoint, issuer);
-  const tokenEndpoint = endpointOf(body.token_endpoint, issuer);
-  if (authorizationEndpoint === '' || tokenEndpoint === '')
-    throw refused(
-      `${issuer.hostname} advertises OAuth but not where to sign in.`,
-    );
-  const methods = body.code_challenge_methods_supported;
-  const offered = stringOf(body.registration_endpoint);
-  const registration = webAddress(offered) ? offered : '';
-  return {
-    issuer: stringOf(body.issuer) === '' ? issuer.origin : stringOf(body.issuer),
-    authorizationEndpoint,
-    tokenEndpoint,
-    registrationEndpoint: registration === '' ? null : registration,
-    supportsS256: Array.isArray(methods) ? methods.includes('S256') : false,
-    scopes,
-  };
-}
-
 export function authServerMetadataUrls(issuer: URL): URL[] {
   const path = issuer.pathname.replace(/\/$/, '');
   const suffixes = ['oauth-authorization-server', 'openid-configuration'];
@@ -137,14 +35,3 @@ export function authServerMetadataUrls(issuer: URL): URL[] {
   );
   return [...aware, new URL(`${path}/.well-known/openid-configuration`, issuer.origin), ...urls];
 }
-
-export async function discoverOAuth(resource: URL, fetchImpl: FetchLike = fetch): Promise<OAuthServer> {
-  const { issuer, scopes } = await resourceMetadata(resource, fetchImpl);
-  for (const candidate of authServerMetadataUrls(issuer)) {
-    const body = await getJson(candidate, fetchImpl);
-    if (body !== null) return toServer(body, issuer, scopes);
-  }
-  throw refused(
-    `${resource.hostname} needs authorization, but publishes no OAuth metadata Metro can use.`,
-  );
-}

package/runtime/node_modules/@metro-labs/http/src/connector-input.ts

@@ -10,7 +10,7 @@ const CLIENT_ID_RE = /^[\x21-\x7e]{1,256}$/;
 const CLIENT_SECRET_RE = /^[\x21-\x7e]{1,1024}$/;
 const DEFAULT_HEADER = 'Authorization';
 
-export class ConnectorError extends ApiError {}
+class ConnectorError extends ApiError {}
 
 function hasControlChar(value: string): boolean {
   for (const ch of value) {

package/runtime/node_modules/@metro-labs/http/src/connector-mcp.ts

@@ -10,7 +10,7 @@ export interface OAuthTokens {
   expiresAt?: number;
 }
 
-export interface OAuthAuth extends OAuthTokens {
+interface OAuthAuth extends OAuthTokens {
   kind: 'oauth';
   issuer: string;
   tokenEndpoint: string;
@@ -30,10 +30,6 @@ export interface VerifiedServer {
   server: string;
 }
 
-export interface VerifiedRecord extends VerifiedServer {
-  at: string;
-}
-
 const PROBE_TIMEOUT_MS = 10_000;
 
 export const INITIALIZE = {
@@ -49,12 +45,21 @@ export function authHeaders(auth: ConnectorAuth): Record<string, string> {
   return {};
 }
 
-export function payloadOf(text: string, contentType: string): string {
+function payloadOf(text: string, contentType: string): string {
   if (!contentType.includes('text/event-stream')) return text;
   for (const line of text.replace(/\r\n/g, '\n').split('\n')) if (line.startsWith('data:')) return line.slice(5).trim();
   return '';
 }
 
+export function resultOf(text: string, contentType: string): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(payloadOf(text, contentType));
+    return isRecord(parsed) && isRecord(parsed.result) ? parsed.result : null;
+  } catch {
+    return null;
+  }
+}
+
 export async function mcpPost(
   url: URL,
   auth: ConnectorAuth,
@@ -77,13 +82,7 @@ export async function mcpPost(
 }
 
 function serverNameOf(url: URL, text: string, contentType: string): string {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(payloadOf(text, contentType));
-  } catch {
-    throw refused(`${url.hostname} answered, but it does not speak MCP.`);
-  }
-  const result = isRecord(parsed) && isRecord(parsed.result) ? parsed.result : null;
+  const result = resultOf(text, contentType);
   if (result === null || typeof result.protocolVersion !== 'string') throw refused(`${url.hostname} answered, but it does not speak MCP.`);
   const info = isRecord(result.serverInfo) ? result.serverInfo : {};
   const title = typeof info.title === 'string' ? info.title : '';

package/runtime/node_modules/@metro-labs/http/src/connector-oauth.ts

@@ -22,7 +22,7 @@ export function newVerifier(): string {
   return randomBytes(32).toString('base64url');
 }
 
-export function challengeOf(verifier: string): string {
+function challengeOf(verifier: string): string {
   return createHash('sha256').update(verifier).digest('base64url');
 }
 

package/runtime/node_modules/@metro-labs/http/src/connector-policy.ts

@@ -1,6 +1,6 @@
 import { isRecord } from '@metro-labs/core/is-record';
 
-export type ConnectorDecision = 'allow' | 'ask' | 'deny';
+type ConnectorDecision = 'allow' | 'ask' | 'deny';
 
 type ToolGroup = 'read' | 'write';
 
@@ -45,11 +45,6 @@ function toolPolicyOf(value: unknown): Record<string, ConnectorDecision> {
   return out;
 }
 
-export function connectorPolicyLayersOf(value: unknown): ConnectorPolicyLayers {
-  if (!isRecord(value) || Object.keys(value).some((key) => !['organization', 'agent'].includes(key))) throw new Error('Invalid connector policy layers.');
-  return { organization: connectorPolicyOf(value.organization), agent: connectorPolicyOf(value.agent) };
-}
-
 const strictest = (...values: (ConnectorDecision | undefined)[]): ConnectorDecision => values.reduce<ConnectorDecision>((held, next) => next !== undefined && RANK[next] > RANK[held] ? next : held, 'allow');
 const toolRule = (policy: ConnectorPolicy, name: string): ConnectorDecision | undefined => policy.tools !== undefined && Object.hasOwn(policy.tools, name) ? policy.tools[name] : undefined;
 const toolGroup = (groups: Record<string, ToolGroup>, name: string): ToolGroup => Object.hasOwn(groups, name) && groups[name] === 'read' ? 'read' : 'write';

package/runtime/node_modules/@metro-labs/http/src/connector-public-url.ts

@@ -40,14 +40,16 @@ export function parsePublicConnectorUrl(raw: unknown): URL {
   return url;
 }
 
+const RESOURCE_REFUSED = 'The public OAuth resource must be a public HTTPS identifier without a query, user information or a fragment. Do not enter credentials.';
+
 export function publicOAuthResource(raw: unknown): string {
   try {
     const url = parsePublicConnectorUrl(raw);
     if (typeof raw === 'string' && !raw.includes('?') && url.search === '') return raw;
   } catch {
-    throw refused('The public OAuth resource must be a public HTTPS identifier without a query, user information or a fragment. Do not enter credentials.');
+    throw refused(RESOURCE_REFUSED);
   }
-  throw refused('The public OAuth resource must be a public HTTPS identifier without a query, user information or a fragment. Do not enter credentials.');
+  throw refused(RESOURCE_REFUSED);
 }
 
 export function optionalOAuthResource(raw: unknown): string | undefined {

package/runtime/node_modules/@metro-labs/http/src/connector-tools.ts

@@ -1,7 +1,7 @@
 import { isRecord } from '@metro-labs/core/is-record';
 import { errMsg, log } from '@metro-labs/core/log';
 import type { FetchLike } from '@metro-labs/core/stations/oauth';
-import { authHeaders, INITIALIZE, mcpPost, payloadOf, type ConnectorAuth } from './connector-mcp.js';
+import { authHeaders, INITIALIZE, mcpPost, resultOf, type ConnectorAuth } from './connector-mcp.js';
 import { ConnectorUnauthorized, refused } from './connector-url.js';
 
 export interface RemoteTool {
@@ -18,16 +18,6 @@ const TIMEOUT_MS = 15_000;
 const MAX_PAGES = 100;
 const MAX_TOOLS = 2000;
 
-function resultOf(text: string, contentType: string): Record<string, unknown> | null {
-  let parsed: unknown = null;
-  try {
-    parsed = JSON.parse(payloadOf(text, contentType));
-  } catch {
-    return null;
-  }
-  return isRecord(parsed) && isRecord(parsed.result) ? parsed.result : null;
-}
-
 async function rpc(url: URL, auth: ConnectorAuth, session: Map<string, string>, body: unknown, fetchImpl?: FetchLike): Promise<Record<string, unknown> | null> {
   const res = await mcpPost(url, auth, body, { timeoutMs: TIMEOUT_MS, headers: Object.fromEntries(session), fetch: fetchImpl });
   const id = res.headers.get('mcp-session-id');

package/runtime/node_modules/@metro-labs/http/src/connector-url.ts

@@ -29,9 +29,3 @@ export function parseConnectorUrl(raw: unknown): URL {
   refuseShape(url);
   return url;
 }
-
-export function connectorUrlText(url: URL): string {
-  const text = url.toString();
-  if (url.pathname !== '/' || url.search !== '') return text;
-  return text.endsWith('/') ? text.slice(0, -1) : text;
-}

package/runtime/node_modules/@metro-labs/http/src/mcp-server-protocol.ts

@@ -4,7 +4,7 @@ export const MCP_PATHS = { token: '/v1/token', approvals: '/v1/approvals', answe
 export const MCP_FIND_DEFAULT = 5;
 export const MCP_FIND_MAX = 20;
 export const MCP_CALLS_MAX = 10;
-export const MCP_QUERY_MAX = 500;
+const MCP_QUERY_MAX = 500;
 export const MCP_APPROVAL_WAIT_MS = 25_000;
 export const MCP_APPROVAL_ID_RE = /^[a-km-z]{5}$/;
 export const TOOL_SEARCH = 'tool_search';

package/runtime/node_modules/@metro-labs/http/src/mcp-server-tools.ts

@@ -96,8 +96,6 @@ const toolCallDescription = (place: ApprovalPlace): string =>
     '- vendor_error: the connector answered with its own error, shown as it came.',
   ].join('\n');
 
-export const TOOL_CALL_DESCRIPTION = toolCallDescription('session');
-
 export function mcpServerTools(connectors: ConnectorLabel[] | null, place: ApprovalPlace = 'session'): McpServerTool[] {
   return [
     {

package/runtime/node_modules/@metro-labs/http/src/mode-api.ts

@@ -3,7 +3,7 @@ import { cors, sendJson } from './api-http.js';
 
 const PATH = '/api/mode';
 
-export type DaemonMode = 'hosted' | 'local';
+type DaemonMode = 'hosted' | 'local';
 
 export interface ModeInfo {
   mode: DaemonMode;

package/runtime/node_modules/@metro-labs/http/src/return-to.ts

@@ -1,12 +1,12 @@
 const PREVIEW = /^([a-z0-9-]+--)?metro-ui\.netlify\.app$/;
 
-export function allowedWebHost(host: string): boolean {
+function allowedWebHost(host: string): boolean {
   if (host === 'metro.box' || host === 'localhost' || host === '127.0.0.1')
     return true;
   return PREVIEW.test(host);
 }
 
-export const APP_RETURN = 'metro://auth';
+const APP_RETURN = 'metro://auth';
 
 export const isAppReturn = (returnTo: string): boolean => returnTo === APP_RETURN;
 

package/runtime/node_modules/@metro-labs/http/src/workos-token.ts

@@ -1,10 +1,11 @@
 import type { IncomingMessage } from 'node:http';
 import { createPublicKey, verify, type JsonWebKey, type KeyObject } from 'node:crypto';
+import { isRecord } from '@metro-labs/core/is-record';
 
 const WORKOS_API = 'https://api.workos.com';
 const ORG_RE = /^org_[A-Za-z0-9]{10,64}$/;
 export const isOrganizationId = (value: string): boolean => ORG_RE.test(value);
-export const DEFAULT_CLIENT_ID = 'client_01M2TJJJ6RM9CT081QB4XZK3G2';
+const DEFAULT_CLIENT_ID = 'client_01M2TJJJ6RM9CT081QB4XZK3G2';
 const SKEW_S = 60;
 const REFETCH_COOLDOWN_MS = 60_000;
 const FETCH_MS = 10_000;
@@ -34,14 +35,12 @@ export const jwksUrl = (id: string, base = WORKOS_API): string => `${base}/sso/j
 function jwksKeys(text: string): Map<string, KeyObject> {
   const keys = new Map<string, KeyObject>();
   const parsed: unknown = JSON.parse(text);
-  const list = typeof parsed === 'object' && parsed !== null ? (parsed as { keys?: unknown }).keys : undefined;
+  const list = isRecord(parsed) ? parsed.keys : undefined;
   if (!Array.isArray(list)) return keys;
   for (const jwk of list) {
-    if (typeof jwk !== 'object' || jwk === null) continue;
-    const { kid, kty } = jwk as { kid?: unknown; kty?: unknown };
-    if (typeof kid !== 'string' || kty !== 'RSA') continue;
+    if (!isRecord(jwk) || typeof jwk.kid !== 'string' || jwk.kty !== 'RSA') continue;
     try {
-      keys.set(kid, createPublicKey({ key: jwk as JsonWebKey, format: 'jwk' }));
+      keys.set(jwk.kid, createPublicKey({ key: jwk as JsonWebKey, format: 'jwk' }));
     } catch {
       continue;
     }
@@ -93,7 +92,7 @@ const b64url = (text: string): Buffer => Buffer.from(text.replace(/-/g, '+').rep
 function jsonPart(text: string): Record<string, unknown> | null {
   try {
     const parsed: unknown = JSON.parse(b64url(text).toString('utf8'));
-    return typeof parsed === 'object' && parsed !== null ? (parsed as Record<string, unknown>) : null;
+    return isRecord(parsed) ? parsed : null;
   } catch {
     return null;
   }

package/runtime/node_modules/@metro-labs/inference/package.json

@@ -19,6 +19,7 @@
     "./frames": "./src/frames.ts",
     "./gateway": "./src/gateway.ts",
     "./model-config": "./src/model-config.ts",
+    "./probes": "./src/probes.ts",
     "./served": "./src/served.ts",
     "./tool-search": "./src/tool-search.ts",
     "./usage": "./src/usage.ts"

package/runtime/node_modules/@metro-labs/inference/src/attempts.ts

@@ -3,11 +3,11 @@ import type { OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'no
 import type { RequestKind } from './effort.js';
 import type { Route } from './model-config.js';
 
-export type AttemptOutcome = 'ok' | 'rate_limited' | 'refused' | 'provider_error' | 'cancelled';
+type AttemptOutcome = 'ok' | 'rate_limited' | 'refused' | 'provider_error' | 'cancelled';
 
-export type AttemptKind = 'main' | 'subagent' | 'compaction' | 'chore';
+type AttemptKind = 'main' | 'subagent' | 'compaction' | 'chore';
 
-export interface AttemptTokens {
+interface AttemptTokens {
   input: number;
   output: number;
   cacheRead: number;

package/runtime/node_modules/@metro-labs/inference/src/bedrock.ts

@@ -27,7 +27,7 @@ export function forgetAdaptations(learned: Adaptations): void {
   learned.dropCacheTtl = false;
 }
 
-export interface BedrockUpstream {
+interface BedrockUpstream {
   settings: Connection;
   base: string;
   learned: Adaptations;

package/runtime/node_modules/@metro-labs/inference/src/codex-translate.ts

@@ -13,12 +13,12 @@ const HASH_LEN = 8;
 
 type Item = Record<string, unknown>;
 
-export interface TranslateOptions {
+interface TranslateOptions {
   promptCacheKey: string;
   names?: ToolNames;
 }
 
-export interface ResponsesRequest {
+interface ResponsesRequest {
   model: string;
   instructions?: string;
   input: Item[];

package/runtime/node_modules/@metro-labs/inference/src/delivered.ts

@@ -2,7 +2,7 @@ import { readEffort, type RouteEffort } from '@metro-labs/core/effort';
 import { isRecord } from '@metro-labs/core/is-record';
 import { emptySetup, isProvider, type AuthKind, type ModelSetup, type Account, type Chain, type CodexAccess, type Connection, type Fallback, type Provider, type RouteSource } from './model-config.js';
 
-export interface DeliveredRoute {
+interface DeliveredRoute {
   primary: Fallback | null;
   fallbacks: Fallback[];
   helpers: Chain | null;

package/runtime/node_modules/@metro-labs/inference/src/effort.ts

@@ -86,12 +86,6 @@ export function withEffort(body: Body, effort: string): Body {
   return { ...top, messages: body.messages.map((message: unknown) => (isRecord(message) ? withOwnEffort(message, effort) : message)) };
 }
 
-export function withoutEffort(body: Body): Body {
-  const config = Object.fromEntries(Object.entries(record(body.output_config)).filter(([key]) => key !== 'effort'));
-  if (Object.keys(config).length > 0) return { ...body, output_config: config };
-  return Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'output_config'));
-}
-
 export function effortToApply(body: Body): string | null {
   if (chore(body)) return null;
   const effort = effortOf(body);

package/runtime/node_modules/@metro-labs/inference/src/fallback.ts

@@ -42,7 +42,7 @@ function applies(window: UsageWindow, route: Route, now: number): boolean {
   return scope === null || route.model.toLowerCase().split(/[^a-z0-9]+/).includes(scope);
 }
 
-export function windowsFor(route: Route, now = Date.now()): UsageWindow[] {
+function windowsFor(route: Route, now = Date.now()): UsageWindow[] {
   return (usageOf(route.connection.id)?.windows ?? []).filter((w) => applies(w, route, now));
 }
 
@@ -131,20 +131,22 @@ function primaryOf(setup: ModelSetup): Route | null {
   return { connection: primary.connection, model };
 }
 
-function rowOf(route: Route, now: number): Omit<ChainRow, 'active'> {
-  const reason = notReady(route);
+type Readiness = (route: Route) => string | null;
+
+function rowOf(route: Route, now: number, ready: Readiness): Omit<ChainRow, 'active'> {
+  const reason = ready(route);
   const used = windowsFor(route, now).reduce<number | null>((most, w) => Math.max(most ?? 0, w.used ?? 0), null);
   return { connection: route.connection.id, model: route.model, used, hold: reason === null ? holdOf(route, now) : { reason, until: null } };
 }
 
-export function chainStatus(setup: ModelSetup, now = Date.now()): ChainRow[] {
+export function chainStatus(setup: ModelSetup, now = Date.now(), ready: Readiness = notReady): ChainRow[] {
   const primary = primaryOf(setup);
   if (primary === null) return [];
   const listed = setup.fallbacks.flatMap((f) => {
     const conn = connectionOf(setup, f.connection);
     return conn === null ? [] : [{ connection: conn, model: f.model }];
   });
-  const rows = unique([primary, ...listed]).map((route) => rowOf(route, now));
+  const rows = unique([primary, ...listed]).map((route) => rowOf(route, now, ready));
   const active = Math.max(0, rows.findIndex((row) => row.hold === null));
   return rows.map((row, at) => ({ ...row, active: at === active }));
 }