@zenera/neo 1.1.24 → 1.1.26

package/dist/memory.d.ts

@@ -0,0 +1,115 @@
+import { type AnyTool } from './types.ts';
+export interface MemoryRecord {
+    id: string;
+    /** memory space this record belongs to */
+    scope: string;
+    /** app-defined: 'fact' | 'preference' | 'episode' | … */
+    kind: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    /** optimistic-concurrency token */
+    revision: number;
+}
+export interface MemoryDraft {
+    kind?: string;
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+export interface MemoryPatch {
+    kind?: string;
+    text?: string;
+    metadata?: Record<string, unknown>;
+    /** when given, the update fails unless the stored revision matches */
+    expectedRevision?: number;
+}
+export interface MemoryQuery {
+    /** semantic query; omitted ⇒ pure filter listing */
+    text?: string;
+    filter?: Record<string, unknown>;
+    kind?: string;
+    limit?: number;
+    minScore?: number;
+}
+export interface MemoryHit {
+    record: MemoryRecord;
+    /** 0..1, backend-normalized */
+    score: number;
+}
+/**
+ * Embedding generation is the store's business, not the kernel's: a pgvector
+ * implementation embeds inside `write`/`search`, the in-memory one below falls
+ * back to token overlap. The kernel never sees vectors.
+ */
+export interface MemoryStore {
+    readonly id: string;
+    search(scope: string, q: MemoryQuery): Promise<MemoryHit[]>;
+    get(scope: string, id: string): Promise<MemoryRecord | undefined>;
+    /** `opId` makes writes idempotent under retry/replay */
+    write(scope: string, rec: MemoryDraft, opId: string): Promise<MemoryRecord>;
+    update(scope: string, id: string, patch: MemoryPatch, opId: string): Promise<MemoryRecord>;
+    delete(scope: string, id: string, opId: string): Promise<void>;
+}
+export interface MemoryBinding<TCtx = unknown> {
+    /** MemoryStore id */
+    store: string;
+    /** namespace; default `agent:${agent.name}`. A function is resolved per run. */
+    scope?: string | ((ctx: TCtx) => string);
+    access: 'read' | 'read-write';
+    /** inject top-k matches before an LLM call */
+    autoRecall?: {
+        query: 'last_user_input' | 'none';
+        limit: number;
+    };
+}
+/** A binding with its scope already resolved against the run context. */
+export interface ResolvedBinding {
+    store: string;
+    scope: string;
+    access: 'read' | 'read-write';
+    autoRecall?: {
+        query: 'last_user_input' | 'none';
+        limit: number;
+    };
+}
+export interface MemoryRecallSpec {
+    kind: 'recall';
+    store: string;
+    scope: string;
+    query: MemoryQuery;
+    hits: {
+        id: string;
+        score: number;
+        revision: number;
+    }[];
+    /** the rendered block the model actually saw */
+    content: string;
+}
+export interface MemoryOpSpec {
+    kind: 'op';
+    op: 'write' | 'update' | 'delete';
+    store: string;
+    scope: string;
+    /** sha256(runId, callId) — deterministic, so replay re-issues the same write */
+    opId: string;
+    recordId: string;
+    revision: number;
+    before?: string;
+    after?: string;
+}
+export declare function memoryOpId(runId: string, callId: string): string;
+export declare function renderMemories(hits: MemoryHit[]): string;
+/**
+ * Filtering plus token-overlap scoring, shared by the backends that have no
+ * embeddings of their own. A vector store ignores this and ranks in the
+ * database instead — the kernel only ever sees `MemoryHit[]`.
+ */
+export declare function rankMemories(records: Iterable<MemoryRecord>, q: MemoryQuery): MemoryHit[];
+/**
+ * Memory is reachable both explicitly (these tools) and implicitly (auto-recall
+ * in the runner). Both land in the trajectory; only the explicit path is
+ * visible to the model as a tool.
+ */
+export declare function memoryTools<TCtx>(bindings: ResolvedBinding[]): AnyTool<TCtx>[];
+//# sourceMappingURL=memory.d.ts.map

package/dist/memory.js

@@ -0,0 +1,213 @@
+import { hash } from "./payload.js";
+import { MEMORY_DELETE_TOOL, MEMORY_SEARCH_TOOL, MEMORY_UPDATE_TOOL, MEMORY_WRITE_TOOL, tool, withEffects, } from "./types.js";
+export function memoryOpId(runId, callId) {
+    return hash(`${runId}\u0000${callId}`);
+}
+export function renderMemories(hits) {
+    if (!hits.length) {
+        return '';
+    }
+    const lines = hits.map((h) => `- [${h.record.id}] (${h.record.kind}, score ${h.score.toFixed(2)}) ${h.record.text}`);
+    return `Relevant memories:\n${lines.join('\n')}`;
+}
+// ---------------------------------------------------------------------------
+// Shared ranking
+// ---------------------------------------------------------------------------
+/**
+ * Filtering plus token-overlap scoring, shared by the backends that have no
+ * embeddings of their own. A vector store ignores this and ranks in the
+ * database instead — the kernel only ever sees `MemoryHit[]`.
+ */
+export function rankMemories(records, q) {
+    const limit = q.limit ?? 8;
+    const terms = tokenize(q.text ?? '');
+    const hits = [];
+    for (const rec of records) {
+        if (q.kind && rec.kind !== q.kind) {
+            continue;
+        }
+        if (q.filter && !matches(rec.metadata, q.filter)) {
+            continue;
+        }
+        const score = terms.length ? overlap(terms, tokenize(rec.text)) : 1;
+        if (score <= 0 || (q.minScore !== undefined && score < q.minScore)) {
+            continue;
+        }
+        hits.push({ record: rec, score });
+    }
+    return hits.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+function tokenize(v) {
+    return v
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length > 2);
+}
+function overlap(a, b) {
+    const set = new Set(b);
+    const shared = a.filter((t) => set.has(t)).length;
+    return a.length ? shared / a.length : 0;
+}
+function matches(meta, filter) {
+    return Object.entries(filter).every(([k, v]) => meta?.[k] === v);
+}
+// ---------------------------------------------------------------------------
+// Built-in memory tools
+// ---------------------------------------------------------------------------
+function spaceParam(bindings) {
+    return bindings.length > 1
+        ? { type: 'string', enum: bindings.map((b) => b.scope), description: 'memory space' }
+        : undefined;
+}
+function pick(bindings, space) {
+    const b = space ? bindings.find((x) => x.scope === space) : bindings[0];
+    if (!b) {
+        throw new Error(`unknown memory space: ${space ?? '(default)'}`);
+    }
+    return b;
+}
+/**
+ * Memory is reachable both explicitly (these tools) and implicitly (auto-recall
+ * in the runner). Both land in the trajectory; only the explicit path is
+ * visible to the model as a tool.
+ */
+export function memoryTools(bindings) {
+    if (!bindings.length) {
+        return [];
+    }
+    const writable = bindings.filter((b) => b.access === 'read-write');
+    const space = spaceParam(bindings);
+    const withSpace = (props) => (space ? { ...props, space } : props);
+    const tools = [
+        tool({
+            name: MEMORY_SEARCH_TOOL,
+            description: 'Search long-lived memories.',
+            parameters: {
+                type: 'object',
+                properties: withSpace({
+                    query: { type: 'string' },
+                    kind: { type: 'string' },
+                    limit: { type: 'integer' },
+                }),
+                required: ['query'],
+                additionalProperties: false,
+            },
+            execute: async (args, tc) => {
+                const b = pick(bindings, args.space);
+                const store = tc.services.memoryStore(b.store);
+                const hits = await store.search(b.scope, {
+                    text: args.query,
+                    kind: args.kind,
+                    limit: args.limit,
+                });
+                return hits.map((h) => ({
+                    id: h.record.id,
+                    kind: h.record.kind,
+                    text: h.record.text,
+                    revision: h.record.revision,
+                    score: Number(h.score.toFixed(3)),
+                }));
+            },
+        }),
+    ];
+    if (!writable.length) {
+        return tools;
+    }
+    const wSpace = spaceParam(writable);
+    const withWSpace = (props) => wSpace ? { ...props, space: wSpace } : props;
+    tools.push(tool({
+        name: MEMORY_WRITE_TOOL,
+        description: 'Store a new long-lived memory.',
+        parameters: {
+            type: 'object',
+            properties: withWSpace({ text: { type: 'string' }, kind: { type: 'string' } }),
+            required: ['text'],
+            additionalProperties: false,
+        },
+        execute: async (args, tc) => {
+            const b = pick(writable, args.space);
+            const opId = memoryOpId(tc.state.runId, tc.callId);
+            const rec = await tc.services
+                .memoryStore(b.store)
+                .write(b.scope, { text: args.text, kind: args.kind }, opId);
+            return withEffects(`stored memory ${rec.id}`, {
+                kind: 'memory_op',
+                spec: {
+                    kind: 'op',
+                    op: 'write',
+                    store: b.store,
+                    scope: b.scope,
+                    opId,
+                    recordId: rec.id,
+                    revision: rec.revision,
+                    after: rec.text,
+                },
+            });
+        },
+    }), tool({
+        name: MEMORY_UPDATE_TOOL,
+        description: 'Update an existing memory by id.',
+        parameters: {
+            type: 'object',
+            properties: withWSpace({
+                id: { type: 'string' },
+                text: { type: 'string' },
+                kind: { type: 'string' },
+            }),
+            required: ['id'],
+            additionalProperties: false,
+        },
+        execute: async (args, tc) => {
+            const b = pick(writable, args.space);
+            const store = tc.services.memoryStore(b.store);
+            const before = await store.get(b.scope, args.id);
+            const opId = memoryOpId(tc.state.runId, tc.callId);
+            const rec = await store.update(b.scope, args.id, { text: args.text, kind: args.kind }, opId);
+            return withEffects(`updated memory ${rec.id}`, {
+                kind: 'memory_op',
+                spec: {
+                    kind: 'op',
+                    op: 'update',
+                    store: b.store,
+                    scope: b.scope,
+                    opId,
+                    recordId: rec.id,
+                    revision: rec.revision,
+                    before: before?.text,
+                    after: rec.text,
+                },
+            });
+        },
+    }), tool({
+        name: MEMORY_DELETE_TOOL,
+        description: 'Delete a memory by id.',
+        parameters: {
+            type: 'object',
+            properties: withWSpace({ id: { type: 'string' } }),
+            required: ['id'],
+            additionalProperties: false,
+        },
+        execute: async (args, tc) => {
+            const b = pick(writable, args.space);
+            const store = tc.services.memoryStore(b.store);
+            const before = await store.get(b.scope, args.id);
+            const opId = memoryOpId(tc.state.runId, tc.callId);
+            await store.delete(b.scope, args.id, opId);
+            return withEffects(`deleted memory ${args.id}`, {
+                kind: 'memory_op',
+                spec: {
+                    kind: 'op',
+                    op: 'delete',
+                    store: b.store,
+                    scope: b.scope,
+                    opId,
+                    recordId: args.id,
+                    revision: before?.revision ?? 0,
+                    before: before?.text,
+                },
+            });
+        },
+    }));
+    return tools;
+}
+//# sourceMappingURL=memory.js.map

package/dist/models/factory.d.ts

@@ -150,6 +150,15 @@ export interface ModelRequirement {
 }
 export declare const providerKinds: ProviderKind[];
 export declare function isProviderKind(name: string): name is ProviderKind;
+/**
+ * Vertex serves three request formats behind one account, and the model id
+ * says which: Google's own models through the GenAI API, Claude through
+ * Anthropic's Messages format at `rawPredict`, and every other publisher's
+ * (`xai/grok-4.1-fast-reasoning`, `qwen/qwen3-…-maas`) through the
+ * OpenAI-compatible endpoint, which names its models `publisher/model`.
+ */
+export type VertexRoute = 'gemini' | 'anthropic' | 'openai';
+export declare function vertexRoute(model: string): VertexRoute;
 /**
  * Which knobs each adapter actually reads.
  *
@@ -240,6 +249,21 @@ export declare class ModelRegistry {
     /** A declared kind wins; otherwise a built-in name is its own kind. */
     kindOf(name: string): ProviderKind;
 }
+export interface VertexEndpoint {
+    project: string;
+    location: string;
+    /** `https://…/v1/projects/<project>/locations/<location>` */
+    base: string;
+    /** a fresh access token from Application Default Credentials, or `spec.token` */
+    token: () => Promise<string>;
+}
+/**
+ * Where a Vertex provider's partner models are served, and how to authenticate
+ * there. The GenAI SDK does both for Gemini; nothing does them for Claude or
+ * the OpenAI-compatible endpoint, so they are resolved here the same way:
+ * `project`, then GOOGLE_CLOUD_PROJECT, then the service-account file.
+ */
+export declare function vertexEndpoint(spec?: ProviderSpec, name?: string): VertexEndpoint;
 /**
  * The registry behind the bare `createModel`. An application that never
  * declares a provider still gets shared clients through it, because the

package/dist/models/factory.js

@@ -114,6 +114,20 @@ export const providerKinds = Object.keys(KINDS);
 export function isProviderKind(name) {
     return Object.hasOwn(KINDS, name);
 }
+export function vertexRoute(model) {
+    if (/^(anthropic\/)?claude-/.test(model)) {
+        return 'anthropic';
+    }
+    return model.includes('/') ? 'openai' : 'gemini';
+}
+/** The protocol one model on one kind is spoken in. Only Vertex has more than one. */
+function protocolOf(kind, model) {
+    return kind === 'vertex' ? vertexRoute(model) : KINDS[kind].protocol;
+}
+/** The OpenAI-compatible endpoint on Vertex has chat completions and nothing else. */
+function apisOf(kind, protocol) {
+    return kind === 'vertex' && protocol === 'openai' ? ['chat'] : KINDS[kind].apis;
+}
 // ---------------------------------------------------------------------------
 // Tuning knobs
 // ---------------------------------------------------------------------------
@@ -214,7 +228,11 @@ export class ModelRegistry {
         this.#providers.set(name, spec);
         // Re-declaring after a client was handed out would otherwise leave the
         // old credentials in service for the rest of the process.
-        this.#clients.delete(name);
+        for (const key of this.#clients.keys()) {
+            if (key === name || key.startsWith(`${name}\0`)) {
+                this.#clients.delete(key);
+            }
+        }
         this.#limiters.delete(name);
         return this;
     }
@@ -247,6 +265,17 @@ export class ModelRegistry {
         this.#clients.set(name, built);
         return built;
     }
+    /** A Vertex provider's Claude or partner client: built once, beside its GenAI one. */
+    #partner(name, protocol, spec) {
+        const key = `${name}\0${protocol}`;
+        const existing = this.#clients.get(key);
+        if (existing) {
+            return existing;
+        }
+        const built = buildVertexPartner(name, protocol, spec);
+        this.#clients.set(key, built);
+        return built;
+    }
     /**
      * The pacing shared by every embedder on a provider, so that what one of
      * them learns from a 429 the others do not have to learn again — and so
@@ -275,14 +304,16 @@ export class ModelRegistry {
      */
     knobs(ref) {
         const spec = typeof ref === 'string' ? this.parse(ref) : ref;
-        const defaults = KINDS[this.kindOf(spec.provider ?? this.#default)];
-        if (defaults.protocol !== 'openai') {
-            return unreadKnobs(spec, defaults.protocol);
+        const kind = this.kindOf(spec.provider ?? this.#default);
+        const protocol = protocolOf(kind, spec.model);
+        if (protocol !== 'openai') {
+            return unreadKnobs(spec, protocol);
         }
         // An api this vendor does not speak already has an error of its own;
         // answering about its knobs would only bury it.
-        const api = spec.api ?? defaults.apis[0];
-        return api && defaults.apis.includes(api) ? unreadKnobs(spec, `openai/${api}`) : [];
+        const apis = apisOf(kind, protocol);
+        const api = spec.api ?? apis[0];
+        return api && apis.includes(api) ? unreadKnobs(spec, `openai/${api}`) : [];
     }
     /** Turns a shorthand or a spec into a `Model`. */
     model(ref) {
@@ -290,7 +321,7 @@ export class ModelRegistry {
         const name = spec.provider ?? this.#default;
         const provider = this.#spec(name);
         const kind = this.kindOf(name);
-        const defaults = KINDS[kind];
+        const protocol = protocolOf(kind, spec.model);
         // Before the client, so a knob for the wrong vendor is reported as the
         // config mistake it is rather than behind a missing credential.
         const [stray] = this.knobs(spec);
@@ -302,30 +333,35 @@ export class ModelRegistry {
         // different connection, and handing back the memoized one would
         // silently ignore them.
         const client = spec.client ??
-            (hasCredentials(spec) ? buildClient(name, kind, spec, provider) : this.client(name));
+            (protocol !== KINDS[kind].protocol
+                ? this.#partner(name, protocol, provider)
+                : hasCredentials(spec)
+                    ? buildClient(name, kind, spec, provider)
+                    : this.client(name));
         // The *resolved* name, not `spec.provider`: a bare ref carries none,
         // and a failure that cannot say which connection refused it is the
         // thing this is here to prevent.
         const options = { ...spec, provider: name };
         // Every protocol but OpenAI's has exactly one API, so naming one is a
         // mistake worth reporting rather than a field to ignore.
-        if (defaults.protocol !== 'openai') {
+        if (protocol !== 'openai') {
             if (spec.api) {
                 throw new TypeError(`provider "${name}" (${kind}) has one api, so "${spec.api}" means nothing here`);
             }
-            switch (defaults.protocol) {
+            switch (protocol) {
                 case 'anthropic':
-                    return new AnthropicModel(spec.model, client, options);
+                    return new AnthropicModel(spec.model.replace(/^anthropic\//, ''), client, options);
                 case 'gemini':
                     return new GeminiModel(spec.model, client, options);
                 case 'openrouter':
                     return new OpenRouterModel(spec.model, client, options);
             }
         }
-        const api = spec.api ?? defaults.apis[0];
-        if (!defaults.apis.includes(api)) {
+        const apis = apisOf(kind, protocol);
+        const api = spec.api ?? apis[0];
+        if (!apis.includes(api)) {
             throw new TypeError(`provider "${name}" (${kind}) does not speak the "${api}" api ` +
-                `(supported: ${defaults.apis.join(', ')})`);
+                `(supported: ${apis.join(', ')})`);
         }
         return api === 'responses'
             ? new OpenAIResponsesModel(spec.model, client, options)
@@ -658,6 +694,109 @@ function projectFromKeyFile() {
         return undefined;
     }
 }
+// ---------------------------------------------------------------------------
+// Vertex partner models
+// ---------------------------------------------------------------------------
+/** Gemini has these; the partner endpoints do not, and answer them with a bare 404. */
+const MULTI_REGIONS = new Set(['us', 'eu']);
+/**
+ * Where a Vertex provider's partner models are served, and how to authenticate
+ * there. The GenAI SDK does both for Gemini; nothing does them for Claude or
+ * the OpenAI-compatible endpoint, so they are resolved here the same way:
+ * `project`, then GOOGLE_CLOUD_PROJECT, then the service-account file.
+ */
+export function vertexEndpoint(spec = {}, name = 'vertex') {
+    const where = `provider "${name}"`;
+    const project = expand(spec.project, `${where}: project`) ??
+        fromEnv('GOOGLE_CLOUD_PROJECT') ??
+        projectFromKeyFile();
+    if (!project) {
+        throw new Error(`${where}: Claude and partner models on vertex need \`project\`, or ` +
+            `GOOGLE_CLOUD_PROJECT, and a service account — an express-mode key reaches Gemini only`);
+    }
+    const named = expand(spec.location, `${where}: location`) ?? fromEnv('GOOGLE_CLOUD_LOCATION') ?? 'global';
+    const location = MULTI_REGIONS.has(named) ? 'global' : named;
+    const host = location === 'global'
+        ? 'https://aiplatform.googleapis.com'
+        : `https://${location}-aiplatform.googleapis.com`;
+    const token = spec.token;
+    return {
+        project,
+        location,
+        base: `${host}/v1/projects/${project}/locations/${location}`,
+        token: token ? async () => token() : adcToken(),
+    };
+}
+/** Mints and refreshes tokens the way the GenAI SDK does for Gemini. */
+function adcToken() {
+    let auth;
+    return async () => {
+        if (!auth) {
+            // `@google/genai`'s own dependency, so it is resolved from there rather than declared twice.
+            const genai = sdkPath('@google/genai', 'vertex');
+            const { GoogleAuth } = createRequire(genai)('google-auth-library');
+            auth = new GoogleAuth({ scopes: ['https://www.googleapis.com/auth/cloud-platform'] });
+        }
+        const token = await auth.getAccessToken();
+        if (!token) {
+            throw new Error('vertex: Application Default Credentials gave no access token');
+        }
+        return token;
+    };
+}
+function sdkPath(pkg, kind) {
+    try {
+        return requirePeer.resolve(pkg);
+    }
+    catch (cause) {
+        throw new Error(`provider kind "${kind}" needs ${pkg}, which is not installed — run: npm i ${pkg}`, { cause });
+    }
+}
+function buildVertexPartner(name, protocol, opts) {
+    const at = vertexEndpoint(opts, name);
+    const common = {
+        apiKey: OAUTH_PLACEHOLDER,
+        defaultHeaders: expandHeaders(opts.headers, `provider "${name}"`),
+        timeout: opts.timeoutMs,
+        maxRetries: retriesOf(opts),
+    };
+    if (protocol === 'anthropic') {
+        const { Anthropic } = sdk('@anthropic-ai/sdk', 'vertex');
+        return new Anthropic({
+            ...common,
+            baseURL: at.base,
+            fetch: funded(rawPredictFetch(at.base, at.token)),
+        });
+    }
+    const { OpenAI } = sdk('openai', 'vertex');
+    return new OpenAI({
+        ...common,
+        baseURL: `${at.base}/endpoints/openapi`,
+        fetch: funded(bearerFetch(at.token)),
+    });
+}
+/**
+ * Anthropic's client posts to `/v1/messages`; Vertex wants the model in the
+ * path and its own `anthropic_version` in the body instead.
+ */
+function rawPredictFetch(base, token) {
+    const authed = bearerFetch(token);
+    return async (input, init) => {
+        const url = input instanceof Request ? input.url : String(input);
+        if (!new URL(url).pathname.endsWith('/v1/messages') || typeof init?.body !== 'string') {
+            return authed(input, init);
+        }
+        const { model, ...body } = JSON.parse(init.body);
+        const headers = new Headers(init.headers);
+        headers.delete('x-api-key');
+        const verb = body.stream ? 'streamRawPredict' : 'rawPredict';
+        return authed(`${base}/publishers/anthropic/models/${model}:${verb}`, {
+            ...init,
+            headers,
+            body: JSON.stringify({ ...body, anthropic_version: 'vertex-2023-10-16' }),
+        });
+    };
+}
 // Both SDKs refuse to construct without a key. When a token callback owns the
 // Authorization header this value is never sent, so it only has to be non-empty.
 const OAUTH_PLACEHOLDER = 'oauth';

package/dist/project/config.d.ts

@@ -48,10 +48,10 @@ declare const modelSpec: z.ZodObject<{
     thinkingBudgetTokens: z.ZodOptional<z.ZodInt>;
     thinkingBudget: z.ZodOptional<z.ZodInt>;
     thinkingLevel: z.ZodOptional<z.ZodEnum<{
+        minimal: "minimal";
         low: "low";
         medium: "medium";
         high: "high";
-        minimal: "minimal";
     }>>;
     includeThoughts: z.ZodOptional<z.ZodBoolean>;
     routing: z.ZodOptional<z.ZodObject<{
@@ -163,15 +163,15 @@ declare const sandbox: z.ZodObject<{
     cpus: z.ZodOptional<z.ZodNumber>;
     memory: z.ZodOptional<z.ZodInt>;
     network: z.ZodOptional<z.ZodEnum<{
+        bridge: "bridge";
         none: "none";
         host: "host";
-        bridge: "bridge";
     }>>;
     workdir: z.ZodOptional<z.ZodString>;
     timeout: z.ZodOptional<z.ZodInt>;
     hardening: z.ZodOptional<z.ZodEnum<{
-        strict: "strict";
         standard: "standard";
+        strict: "strict";
     }>>;
     user: z.ZodOptional<z.ZodString>;
     persist: z.ZodOptional<z.ZodBoolean>;
@@ -220,10 +220,10 @@ export declare const projectSchema: z.ZodObject<{
         thinkingBudgetTokens: z.ZodOptional<z.ZodInt>;
         thinkingBudget: z.ZodOptional<z.ZodInt>;
         thinkingLevel: z.ZodOptional<z.ZodEnum<{
+            minimal: "minimal";
             low: "low";
             medium: "medium";
             high: "high";
-            minimal: "minimal";
         }>>;
         includeThoughts: z.ZodOptional<z.ZodBoolean>;
         routing: z.ZodOptional<z.ZodObject<{
@@ -293,15 +293,15 @@ export declare const projectSchema: z.ZodObject<{
         cpus: z.ZodOptional<z.ZodNumber>;
         memory: z.ZodOptional<z.ZodInt>;
         network: z.ZodOptional<z.ZodEnum<{
+            bridge: "bridge";
             none: "none";
             host: "host";
-            bridge: "bridge";
         }>>;
         workdir: z.ZodOptional<z.ZodString>;
         timeout: z.ZodOptional<z.ZodInt>;
         hardening: z.ZodOptional<z.ZodEnum<{
-            strict: "strict";
             standard: "standard";
+            strict: "strict";
         }>>;
         user: z.ZodOptional<z.ZodString>;
         persist: z.ZodOptional<z.ZodBoolean>;
@@ -325,8 +325,8 @@ export declare const projectSchema: z.ZodObject<{
             provider: z.ZodOptional<z.ZodString>;
             discovery: z.ZodDefault<z.ZodEnum<{
                 none: "none";
-                search: "search";
                 index: "index";
+                search: "search";
             }>>;
             allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
             preload: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -357,15 +357,15 @@ export declare const projectSchema: z.ZodObject<{
             cpus: z.ZodOptional<z.ZodNumber>;
             memory: z.ZodOptional<z.ZodInt>;
             network: z.ZodOptional<z.ZodEnum<{
+                bridge: "bridge";
                 none: "none";
                 host: "host";
-                bridge: "bridge";
             }>>;
             workdir: z.ZodOptional<z.ZodString>;
             timeout: z.ZodOptional<z.ZodInt>;
             hardening: z.ZodOptional<z.ZodEnum<{
-                strict: "strict";
                 standard: "standard";
+                strict: "strict";
             }>>;
             user: z.ZodOptional<z.ZodString>;
             persist: z.ZodOptional<z.ZodBoolean>;