- Providers/Ollama: accept OpenAI SDK-style `baseURL` as an alias for `baseUrl` across discovery, streaming, setup pulls, embeddings, and web search so remote Ollama hosts are not silently ignored. Fixes #62533; supersedes #62549. Thanks @Julien-BKK and @Linux2010.

- Providers/Ollama: scope synthetic local auth and embedding bearer headers to declared Ollama host boundaries so cloud keys are not sent to local/self-hosted embedding endpoints and remote/cloud Ollama endpoints no longer receive the `ollama-local` marker as if it were a real token. Supersedes #69261 and #69857; refs #43945. Thanks @hyspacex, @maxramsay, and @Meli73.

- Providers/Ollama: resolve custom-named local Ollama providers such as `ollama-remote` through the Ollama synthetic-auth hook so subagents no longer miss `ollama-local` auth and silently fall back to cloud models. Fixes #43945. Thanks @Meli73 and @maxramsay.

- Providers/Ollama: add provider-scoped model request timeouts, thread them through guarded fetch connect/header/body/abort handling, and document `params.keep_alive` for cold local models so first-turn Ollama loads no longer require global agent timeout changes. Fixes #64541 and #68796; supersedes #65143 and #66511. Thanks @LittleJakub, @Juankcba, @uninhibite-scholar, and @yfge.

- Providers/PDF/Ollama: add bounded network timeouts for Ollama model pulls and native Anthropic/Gemini PDF analysis requests so unresponsive provider endpoints no longer hang sessions indefinitely. Fixes #54142; supersedes #54144 and #54145. Thanks @jinduwang1001-max and @arkyu2077.

- Memory/doctor: treat Ollama memory embeddings as key-optional so `openclaw doctor` no longer warns about a missing API key when the gateway reports embeddings are ready. Fixes #46584. Thanks @fengly78.

- Agents/Ollama: apply provider-owned replay turn normalization to native Ollama chat so Cloud models no longer reject non-alternating replay history in agent/Gateway runs. Fixes #71697. Thanks @ismael-81.

0c3eaaee031f0adec2fcfc8a3a6a0d80dfc19d4d1c10b0ff4249b30e04b3c47d config-baseline.json

420269ce22f17382cb253c80a232329e943296be101cda313506341ae39cc674 config-baseline.core.json

6fceeca87ecf3245c9f3a184f1ec66c8dee8df6e5a14c6d9d1924557f8d36408 config-baseline.json

15b6223907d0930307e950752e6498edc40f7df597e8e36914490f7611eab413 config-baseline.core.json

07963db49502132f26db396c56b36e018b110e6c55a68b3cb012d3ec96f43901 config-baseline.channel.json

74b74cb18ac37c0acaa765f398f1f9edbcee4c43567f02d45c89598a1e13afb4 config-baseline.plugin.json

- `agent.wait` default: 30s (just the wait). `timeoutMs` param overrides.

- Agent runtime: `agents.defaults.timeoutSeconds` default 172800s (48 hours); enforced in `runEmbeddedPiAgent` abort timer.

- LLM idle timeout: `agents.defaults.llm.idleTimeoutSeconds` aborts a model request when no response chunks arrive before the idle window. Set it explicitly for slow local models or reasoning/tool-call providers; set it to 0 to disable. If it is not set, OpenClaw uses `agents.defaults.timeoutSeconds` when configured, otherwise 120s. Cron-triggered runs with no explicit LLM or agent timeout disable the idle watchdog and rely on the cron outer timeout.

- Provider HTTP request timeout: `models.providers.<id>.timeoutSeconds` applies only to that provider's model HTTP fetches, including connect, headers, body, and total guarded-fetch abort handling. Use this for slow local/self-hosted providers such as Ollama before raising the whole agent runtime timeout.

## Where things can end early

- `models.providers.*.api`: request adapter (`openai-completions`, `openai-responses`, `anthropic-messages`, `google-generative-ai`, etc).

- `models.providers.*.apiKey`: provider credential (prefer SecretRef/env substitution).

- `models.providers.*.auth`: auth strategy (`api-key`, `token`, `oauth`, `aws-sdk`).

- `models.providers.*.timeoutSeconds`: optional per-provider model HTTP request timeout in seconds, including connect, headers, body, and total request abort handling.

- `models.providers.*.injectNumCtxForOpenAICompat`: for Ollama + `openai-completions`, inject `options.num_ctx` into requests (default: `true`).

- `models.providers.*.authHeader`: force credential transport in the `Authorization` header when required.

- `models.providers.*.baseUrl`: upstream API base URL.

apiKey: "ollama-local",

baseUrl: "http://ollama-host:11434", // No /v1 - use native Ollama API URL

api: "ollama", // Set explicitly to guarantee native tool-calling behavior

timeoutSeconds: 300, // Optional: give cold local models longer to connect and stream

models: [

{

id: "qwen3:32b",

name: "qwen3:32b",

params: {

keep_alive: "15m", // Optional: keep the model loaded between turns

},

},

],

},

},

},

provider prefix, such as `ollama-spark/qwen3:32b`, OpenClaw strips only that

prefix before calling Ollama so the server receives `qwen3:32b`.

For slow local models, prefer provider-scoped request tuning before raising the

whole agent runtime timeout:

```json5

{

models: {

providers: {

ollama: {

timeoutSeconds: 300,

models: [

{

id: "gemma4:26b",

name: "gemma4:26b",

params: { keep_alive: "15m" },

},

],

},

},

},

}

```

`timeoutSeconds` applies to the model HTTP request, including connection setup,

headers, body streaming, and the total guarded-fetch abort. `params.keep_alive`

is forwarded to Ollama as top-level `keep_alive` on native `/api/chat` requests;

set it per model when first-turn load time is the bottleneck.

## Ollama Web Search

OpenClaw supports **Ollama Web Search** as a bundled `web_search` provider.

```

</Accordion>

<Accordion title="Cold local model times out">

Large local models can need a long first load before streaming begins. Keep the timeout scoped to the Ollama provider, and optionally ask Ollama to keep the model loaded between turns:

```json5

{

models: {

providers: {

ollama: {

timeoutSeconds: 300,

models: [

{

id: "gemma4:26b",

name: "gemma4:26b",

params: { keep_alive: "15m" },

},

],

},

},

},

}

```

If the host itself is slow to accept connections, `timeoutSeconds` also extends the guarded Undici connect timeout for this provider.

</Accordion>

</AccordionGroup>

<Note>

| {

model?: string;

think?: boolean;

keep_alive?: string;

options?: { num_ctx?: number; top_p?: number };

tools?: Array<{

function?: {

api: "ollama",

provider: PROVIDER_ID,

contextWindow: 8192,

params: { num_ctx: 4096, top_p: 0.9, thinking: false },

params: { num_ctx: 4096, top_p: 0.9, thinking: false, keep_alive: "5m" },

requestTimeoutMs: 120_000,

} as never,

{

messages: [{ role: "user", content: "Reply exactly OK." }],

expect(payload?.options?.num_ctx).toBe(4096);

expect(payload?.options?.top_p).toBe(0.9);

expect(payload?.think).toBe(false);

expect(payload?.keep_alive).toBe("5m");

const properties = payload?.tools?.[0]?.function?.parameters?.properties;

expect(properties?.city?.type).toBe("string");

expect(properties?.units?.type).toBe("string");

url: string;

init?: RequestInit;

policy?: unknown;

timeoutMs?: number;

auditContext?: string;

};

);

});

it("passes resolved provider request timeouts to native Ollama chat fetches", async () => {

await withMockNdjsonFetch(

[

'{"model":"m","created_at":"t","message":{"role":"assistant","content":"ok"},"done":false}',

'{"model":"m","created_at":"t","message":{"role":"assistant","content":""},"done":true,"prompt_eval_count":1,"eval_count":1}',

],

async (fetchMock) => {

const stream = await createOllamaTestStream({

baseUrl: "http://ollama-host:11434",

model: { requestTimeoutMs: 450_000 },

});

await collectStreamEvents(stream);

expect(getGuardedFetchCall(fetchMock).timeoutMs).toBe(450_000);

},

);

});

it("maps native Ollama max thinking to think=high on the wire", async () => {

await withMockNdjsonFetch(

[

return model.headers as Record<string, string>;

}

function resolveOllamaRequestTimeoutMs(

model: object,

options: { requestTimeoutMs?: unknown } | undefined,

): number | undefined {

const raw =

options?.requestTimeoutMs ?? (model as { requestTimeoutMs?: unknown }).requestTimeoutMs;

return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : undefined;

}

export function createOllamaStreamFn(

baseUrl: string,

defaultHeaders?: Record<string, string>,

signal: options?.signal,

},

policy: ssrfPolicy,

timeoutMs: resolveOllamaRequestTimeoutMs(

model,

options as { requestTimeoutMs?: unknown } | undefined,

),

auditContext: "ollama-stream.chat",

});

models?: ModelDefinitionConfig[];

headers?: unknown;

authHeader?: boolean;

timeoutSeconds?: ModelProviderConfig["timeoutSeconds"];

request?: ModelProviderConfig["request"];

};

});

});

it("resolves provider request timeout metadata for configured provider models", () => {

mockDiscoveredModel(discoverModels, {

provider: "ollama",

modelId: "qwen3:32b",

templateModel: {

...makeModel("qwen3:32b"),

provider: "ollama",

},

});

const cfg = {

models: {

providers: {

ollama: {

baseUrl: "http://localhost:11434",

timeoutSeconds: 300,

models: [makeModel("qwen3:32b")],

},

},

},

} as unknown as OpenClawConfig;

const result = resolveModelForTest("ollama", "qwen3:32b", "/tmp/agent", cfg);

expect(result.error).toBeUndefined();

expect((result.model as { requestTimeoutMs?: number } | undefined)?.requestTimeoutMs).toBe(

300_000,

);

});

it("applies agent default model params without explicit provider config", () => {

mockDiscoveredModel(discoverModels, {

provider: "ollama",