@bendyline/gezel-inference 0.0.0-stage → 1.0.0

package/dist/providers/observation-context.d.ts

@@ -0,0 +1,16 @@
+export interface ApiObservationContext {
+    sessionId?: string;
+    gezelId?: string;
+    projectId?: string;
+    taskRef?: string;
+    executionMode?: string;
+    behaviors?: Array<{
+        id: string;
+        config?: unknown;
+    }>;
+    promptSections?: Array<{
+        name: string;
+        tokens: number;
+        band: string;
+    }>;
+}

package/dist/providers/observation-context.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/openai-compatible/sse.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/openai-compatible/sse.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/patient-fetch.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The one `fetch` that local engines are allowed to be slow on.
+ *
+ * Node's global `fetch` is undici, and undici defaults `headersTimeout`
+ * and `bodyTimeout` to 5 minutes. A local inference engine routinely
+ * blows through that before it emits its first byte — a 72k-token
+ * prefill on a 27B at 7 tok/s is a quarter of an hour — and when undici
+ * gives up it throws a bare `TypeError: terminated` that reads exactly
+ * like the engine died.
+ *
+ * Every engine provider already owns its real deadline through an
+ * AbortController budget scaled to prompt size. undici's 5 minutes is a
+ * second, invisible deadline underneath that one, and it is always the
+ * shorter of the two. So: disable it here, and let the provider's own
+ * budget be the only thing that can end a call.
+ *
+ * Wild-caught (mlx qwen3.8-27b-q4): six turns died at ~300s against
+ * declared pre-first-byte budgets of 595s, 722s and 900s. The engine was
+ * healthy throughout — another session was streaming on it at 6.8 tok/s
+ * — and the error told the user the server had crashed or run out of
+ * memory and advised retrying, which could not work: the same prompt
+ * hits the same wall every time. The MLX provider was the only local
+ * engine whose factory never injected a patient fetch, because this
+ * helper had been copy-pasted into five separate modules and MLX was
+ * simply missed. Hence one owner, plus `scripts/check-patient-fetch.mjs`
+ * so the sixth copy cannot be written and a new engine cannot forget.
+ *
+ * NOT for calls that leave this machine. A remote host that goes away
+ * mid-request should fail on a timeout rather than hang forever; web
+ * search, model downloads and registry probes keep the global default.
+ */
+/**
+ * Lazily built so the dispatcher only spins up in a process that
+ * actually talks to a local engine.
+ */
+export declare function patientFetch(): typeof fetch;

package/dist/providers/patient-fetch.js

@@ -0,0 +1,44 @@
+/**
+ * The one `fetch` that local engines are allowed to be slow on.
+ *
+ * Node's global `fetch` is undici, and undici defaults `headersTimeout`
+ * and `bodyTimeout` to 5 minutes. A local inference engine routinely
+ * blows through that before it emits its first byte — a 72k-token
+ * prefill on a 27B at 7 tok/s is a quarter of an hour — and when undici
+ * gives up it throws a bare `TypeError: terminated` that reads exactly
+ * like the engine died.
+ *
+ * Every engine provider already owns its real deadline through an
+ * AbortController budget scaled to prompt size. undici's 5 minutes is a
+ * second, invisible deadline underneath that one, and it is always the
+ * shorter of the two. So: disable it here, and let the provider's own
+ * budget be the only thing that can end a call.
+ *
+ * Wild-caught (mlx qwen3.8-27b-q4): six turns died at ~300s against
+ * declared pre-first-byte budgets of 595s, 722s and 900s. The engine was
+ * healthy throughout — another session was streaming on it at 6.8 tok/s
+ * — and the error told the user the server had crashed or run out of
+ * memory and advised retrying, which could not work: the same prompt
+ * hits the same wall every time. The MLX provider was the only local
+ * engine whose factory never injected a patient fetch, because this
+ * helper had been copy-pasted into five separate modules and MLX was
+ * simply missed. Hence one owner, plus `scripts/check-patient-fetch.mjs`
+ * so the sixth copy cannot be written and a new engine cannot forget.
+ *
+ * NOT for calls that leave this machine. A remote host that goes away
+ * mid-request should fail on a timeout rather than hang forever; web
+ * search, model downloads and registry probes keep the global default.
+ */
+import { Agent, fetch as undiciFetch } from 'undici';
+let cached;
+/**
+ * Lazily built so the dispatcher only spins up in a process that
+ * actually talks to a local engine.
+ */
+export function patientFetch() {
+    if (!cached) {
+        const dispatcher = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
+        cached = ((url, init) => undiciFetch(url, { ...init, dispatcher }));
+    }
+    return cached;
+}

package/dist/providers/project-macro-loop-bail.d.ts

@@ -0,0 +1,7 @@
+/** Shared safeguards for project-kickoff tool loops across local and remote sessions. */
+/** Redundant calls tolerated after a successful kickoff before forcing end-of-turn. */
+export declare const PROJECT_MACRO_INTERCEPT_CAP = 2;
+/** Failed kickoff calls tolerated before returning a visible failure to the user. */
+export declare const PROJECT_MACRO_FAILURE_CAP = 2;
+/** Derive a concise user-facing closing from a successful kickoff result. */
+export declare function deriveProjectMacroClosing(firstResult: string): string;

package/dist/providers/project-macro-loop-bail.js

@@ -0,0 +1,21 @@
+/** Shared safeguards for project-kickoff tool loops across local and remote sessions. */
+/** Redundant calls tolerated after a successful kickoff before forcing end-of-turn. */
+export const PROJECT_MACRO_INTERCEPT_CAP = 2;
+/** Failed kickoff calls tolerated before returning a visible failure to the user. */
+export const PROJECT_MACRO_FAILURE_CAP = 2;
+/** Derive a concise user-facing closing from a successful kickoff result. */
+export function deriveProjectMacroClosing(firstResult) {
+    const projectMatch = firstResult.match(/Started (?:project|job) "([^"]+)"/);
+    const leadMatch = firstResult.match(/Recruited (\S+) as (voorman|builder|lead)/i);
+    const projectName = projectMatch?.[1];
+    const leadName = leadMatch?.[1];
+    const leadRole = leadMatch?.[2];
+    if (projectName && leadName) {
+        const trailer = leadRole === 'voorman' ? ' is leading the crew' : ' is on it';
+        return `Project "${projectName}" is kicked off — ${leadName}${trailer}. You can watch their work surface in this thread.`;
+    }
+    if (projectName) {
+        return `Project "${projectName}" is kicked off — the lead is taking it from here.`;
+    }
+    return 'Project kickoff is on it — the lead is taking it from here.';
+}

package/dist/providers/prose-document-salvage.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/prose-document-salvage.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/provider-disposal.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/provider-disposal.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/queue.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The provider queue lives in core so the daemon and the phone runtime
+ * schedule with one implementation; see
+ * `packages/core/src/runtime/provider-queue.ts`. This module is the
+ * service's import point and keeps the one piece that reads the process
+ * environment.
+ */
+export { AbortedWhileQueuedError, DEFAULT_AMBIENT_QUIET_MS, ProviderQueue, QUEUE_WAIT_NOTICE_DELAY_MS, QUEUE_WAIT_NOTICE_REPEAT_MS, backgroundLaneCap, runInQueue, } from '@bendyline/gezel/runtime';
+export type { EnqueueRequest, Lane, ProviderQueueOptions, QueueSnapshot, QueueWaitOpts, } from '@bendyline/gezel/runtime';
+/**
+ * Ambient quiet window for local engine queues. Override with
+ * `GEZEL_AMBIENT_QUIET_MS` (milliseconds; `0` disables ambient gating
+ * entirely).
+ */
+export declare function defaultAmbientQuietMs(): number;

package/dist/providers/queue.js

@@ -0,0 +1,23 @@
+/**
+ * The provider queue lives in core so the daemon and the phone runtime
+ * schedule with one implementation; see
+ * `packages/core/src/runtime/provider-queue.ts`. This module is the
+ * service's import point and keeps the one piece that reads the process
+ * environment.
+ */
+import { DEFAULT_AMBIENT_QUIET_MS } from '@bendyline/gezel/runtime';
+export { AbortedWhileQueuedError, DEFAULT_AMBIENT_QUIET_MS, ProviderQueue, QUEUE_WAIT_NOTICE_DELAY_MS, QUEUE_WAIT_NOTICE_REPEAT_MS, backgroundLaneCap, runInQueue, } from '@bendyline/gezel/runtime';
+/**
+ * Ambient quiet window for local engine queues. Override with
+ * `GEZEL_AMBIENT_QUIET_MS` (milliseconds; `0` disables ambient gating
+ * entirely).
+ */
+export function defaultAmbientQuietMs() {
+    const raw = process.env.GEZEL_AMBIENT_QUIET_MS;
+    if (raw !== undefined) {
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isFinite(parsed) && parsed >= 0)
+            return parsed;
+    }
+    return DEFAULT_AMBIENT_QUIET_MS;
+}

package/dist/providers/ramble-abort-message.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/ramble-abort-message.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/ramble-detector.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/ramble-detector.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/reasoning-depth.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/reasoning-depth.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/required-input-reads.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/required-input-reads.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/session-defaults.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderName } from '@bendyline/gezel';
+import type { CatalogService } from '@bendyline/gezel-catalog';
+import type { ConfigStore } from '../fs/config-store.js';
+import { type ResolveTuningInput, type ResolvedModelProfile, type ResolvedTuning } from '../model-profile/index.js';
+export declare function resolveModelSessionDefaults(store: Pick<ConfigStore, 'readConfig'>, catalog: CatalogService, providerName: ProviderName, modelId: string | undefined, overrides?: {
+    tuning?: ResolveTuningInput['override'];
+    tuningProfileId?: string;
+    suggestedProfileId?: string;
+    reasoningEffort?: ResolveTuningInput['reasoningEffort'];
+}): Promise<{
+    profile: ResolvedModelProfile;
+    tuning: ResolvedTuning;
+}>;

package/dist/providers/session-defaults.js

@@ -0,0 +1,49 @@
+import { resolveCatalogParameterSize } from '../chat/catalog-model-lookup.js';
+import { classifyLocalModelTier } from '../chat/local-model-tier.js';
+import { resolveProfileForCatalogId, resolveTuning, } from '../model-profile/index.js';
+import { applyBehaviorEnvOverrides } from '../model-profile/runtime.js';
+import { resolveCatalogIdFromModelId } from './catalog-model-config.js';
+export async function resolveModelSessionDefaults(store, catalog, providerName, modelId, overrides = {}) {
+    const config = await store.readConfig();
+    const resolvedModelId = modelId ?? config.defaultModel?.[providerName];
+    const resolvedCatalogId = (await resolveCatalogIdFromModelId(catalog, resolvedModelId)) ?? resolvedModelId;
+    const tier = classifyLocalModelTier({
+        providerName,
+        modelId: resolvedModelId,
+        parameterSize: await resolveCatalogParameterSize(catalog, resolvedCatalogId),
+    });
+    const profile = applyBehaviorEnvOverrides(await resolveProfileForCatalogId({
+        catalog: catalog,
+        catalogId: resolvedCatalogId,
+        tier,
+        providerName,
+    }));
+    const catalogDetail = resolvedCatalogId
+        ? await catalog.get('chat-model', resolvedCatalogId).catch(() => null)
+        : null;
+    const catalogTuning = catalogDetail && catalogDetail.manifest.kind === 'chat-model'
+        ? catalogDetail.manifest.tuning
+        : undefined;
+    const catalogStyle = catalogDetail && catalogDetail.manifest.kind === 'chat-model'
+        ? catalogDetail.manifest.style
+        : undefined;
+    const installDefaultTuning = resolvedCatalogId
+        ? config.modelTuning?.[resolvedCatalogId]
+        : undefined;
+    const installDefaultProfileId = resolvedCatalogId
+        ? config.modelTuningProfile?.[resolvedCatalogId]
+        : undefined;
+    const tuning = resolveTuning({
+        ...(catalogTuning ? { catalog: catalogTuning } : {}),
+        ...(installDefaultTuning ? { installDefault: installDefaultTuning } : {}),
+        ...(overrides.tuning ? { override: overrides.tuning } : {}),
+        ...(overrides.tuningProfileId ? { tuningProfileId: overrides.tuningProfileId } : {}),
+        ...(installDefaultProfileId ? { installDefaultProfileId } : {}),
+        ...(overrides.suggestedProfileId ? { suggestedProfileId: overrides.suggestedProfileId } : {}),
+        ...(catalogStyle?.reasoningFormat
+            ? { styleReasoningFormat: catalogStyle.reasoningFormat }
+            : {}),
+        ...(overrides.reasoningEffort ? { reasoningEffort: overrides.reasoningEffort } : {}),
+    });
+    return { profile, tuning };
+}

package/dist/providers/session-hooks.d.ts

@@ -0,0 +1,26 @@
+import type { HookPhase, HookResult, HookSpec } from '@bendyline/gezel';
+export interface ActiveHook {
+    spec: HookSpec;
+    craftbookId: string;
+    /** Compiled regex from `spec.matcher`. */
+    matcher: RegExp;
+}
+export type HookRunner = (hook: ActiveHook, ctx: {
+    phase: HookPhase;
+    toolName: string;
+    args: Record<string, unknown>;
+    result?: {
+        text: string;
+        isError: boolean;
+    };
+}) => Promise<HookResult>;
+export interface ToolGroundingHooks {
+    checkWrite(toolName: string, args: Record<string, unknown>): {
+        kind: 'reject';
+        error: string;
+    } | {
+        kind: 'allow';
+        args: Record<string, unknown>;
+    } | null;
+    labelEvidence(toolName: string, args: Record<string, unknown>, text: string): string | null;
+}

package/dist/providers/session-hooks.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/streaming-session.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/streaming-session.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/terminal-tool-policy.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/terminal-tool-policy.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/tool-arg-schema-coercion.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/tool-arg-schema-coercion.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/tool-executor.d.ts

@@ -0,0 +1,12 @@
+import type { LocalToolExecutor, LocalToolOutputBudget } from '@bendyline/gezel/local-loop';
+import type { SessionOpts } from './types.js';
+export interface ToolExecutor extends LocalToolExecutor {
+    hasCallableRestriction(): boolean;
+    isRestrictedFromCalling(name: string): boolean;
+    callToolRich(name: string, args: Record<string, unknown>, options?: LocalToolOutputBudget): Promise<{
+        text: string;
+        isError: boolean;
+    }>;
+}
+export type ToolExecutorFactory = (options: SessionOpts, logPrefix: string) => Promise<ToolExecutor>;
+export declare function createToolExecutor(options: SessionOpts, logPrefix: string): Promise<ToolExecutor>;

package/dist/providers/tool-executor.js

@@ -0,0 +1,20 @@
+export async function createToolExecutor(options, logPrefix) {
+    if (options.toolExecutorFactory)
+        return options.toolExecutorFactory(options, logPrefix);
+    if (options.mcpServer || options.extraMcpServers?.length)
+        throw new Error('MCP tools require a host tool executor');
+    return {
+        isEmpty: () => true,
+        getOpenAITools: () => [],
+        hasTool: () => false,
+        hasCallableRestriction: () => false,
+        isRestrictedFromCalling: () => false,
+        callTool: async () => {
+            throw new Error('No host tools are installed');
+        },
+        callToolRich: async () => {
+            throw new Error('No host tools are installed');
+        },
+        stop: async () => { },
+    };
+}

package/dist/providers/tool-failure-tracker.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/tool-failure-tracker.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/tool-repeat-tracker.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/tool-repeat-tracker.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/turn-timeout.d.ts

@@ -0,0 +1 @@
+export declare const OLLAMA_TURN_TIMEOUT_MS: number;

package/dist/providers/turn-timeout.js

@@ -0,0 +1 @@
+export const OLLAMA_TURN_TIMEOUT_MS = 4 * 60 * 60 * 1000;