Arcane Ollama

Arcane Ollama lets an admitted application use local Ollama without knowing the service port, service account, model directory, host process, or native transport. Application code imports one browser module and calls one API:

import ollama from '/arcane/modules/Ollama.js';

const reply = await ollama.chatText({
    model: 'arcane:latest',
    messages: [{role: 'user', content: 'Summarize this record.'}]
});

console.log(reply);

The module never connects directly to localhost:11434. It delegates to the capability-gated globalThis.Arcane.ollama bridge. Core binds application identity, checks the exact method and package-owned model policy, admits native resources, and calls the managed ArcaneOllama service.

This npm package exposes the synchronized browser client only. It does not bundle, install, start, or grant an Arcane Core or ArcaneOllama service. Every native call therefore requires a separately installed, compatible Arcane host, an app-scoped admitted Core session, the required capabilities, and a service that is ready under native policy. Import success alone proves none of those conditions.

What developers can do

Fast start

1. Feature-detect the module

import ollama from '/arcane/modules/Ollama.js';

const readiness = await ollama.readiness();

if (!readiness.ready) {
    console.info('Local AI is unavailable:', readiness.errorCode);
}

readiness() catches a failed version() call and returns a frozen object:

{ ready: boolean, version: string|null, errorCode: string|null }

It is a connectivity convenience, not model admission or inference readiness. Use Arcane.localAI.status() when the application needs the package-filtered runnable model catalog.

2. Read admitted models

const access = await globalThis.Arcane.capabilities.list();

if (!access.methods.includes('localAI.status')) {
    throw new Error('This application is not admitted for local AI.');
}

const status = await globalThis.Arcane.localAI.status();
console.table(status.models.ollama);

Populate product UI from this filtered catalog. ollama.models() is the raw diagnostic inventory for admitted Settings, Shell, or Terminal journeys; it is not the application's package-admitted model list.

3. Stream a chat response

let text = '';

const final = await ollama.chat({
    model: 'arcane:latest',
    messages: [{role: 'user', content: 'Explain the evidence.'}]
}, {
    onChunk(chunk) {
        text += chunk.message?.content ?? '';
    },
    signal: AbortSignal.timeout(60_000)
});

console.log(text, final.done);

Arcane correlates chunks to the originating request. The final promise resolves with Ollama's final bounded chunk/envelope.

Complete module API

/arcane/modules/Ollama.js exports the Ollama class, a frozen ollama singleton, and that singleton as the default export. It also installs the non-writable globalThis.arcaneOllama convenience and emits arcane-ollama-ready. The pinned class defines exactly 24 public methods: the 20 bridge delegates below and the four normalized helpers that follow.

Raw bridge methods

Normalized helper methods

ollama.readiness()

Overview

Calls version() and converts success/failure into a frozen readiness snapshot. It never throws for service unavailability.

Return value

{ready:true, version, errorCode:null} on success, or {ready:false, version:null, errorCode} on failure. A string version and an object {version} are both accepted.

Example

const {ready, version, errorCode} = await ollama.readiness();
console.log(ready ? version : errorCode);

ollama.generateText()

Overview

Calls generate() and coerces the final envelope's response field to a string with String(response?.response || ''). Valid Ollama responses document response as a string. If an out-of-contract response supplies a truthy nonstring, the helper stringifies it; a missing, null, undefined, or other falsy nonstring value becomes an empty string.

Example

const text = await ollama.generateText({
    model: 'arcane:latest',
    prompt: 'Write one sentence.'
});

ollama.chatText()

Overview

Calls chat() and coerces the final envelope's message.content field to a string with String(response?.message?.content || ''). Valid Ollama responses document message.content as a string. If an out-of-contract response supplies a truthy nonstring, the helper stringifies it; a missing, null, undefined, or other falsy nonstring value becomes an empty string. Use chat() when tool calls, metrics, context, or optional provider fields matter.

Example

const text = await ollama.chatText({
    model: 'arcane:latest',
    messages: [{role: 'user', content: 'Hello'}]
});

ollama.unload()

Overview

Translates unload(model) to:

ollama.generate({model, prompt: '', keep_alive: 0});

It returns the raw final generation envelope. It is a convenience request, not a proof that no other admitted client reloaded the model concurrently.

Example

async function unloadAfterTheUserChooses(model) {
    return ollama.unload(model);
}

Availability matrix

Capabilities and policy

• ai.inference admits package-filtered local generation, chat, and embeddings.
• ai.models.read admits raw model diagnostics only to authorized system apps.
• ai.models.manage admits policy-bound managed model lifecycle operations.
• ai.settings.manage admits Settings-owned runtime/service configuration.
• ai.models.unverified.inference is an explicit inference-only exception for already installed, hardware-admitted unverified models when the package says verified_only:false; it does not admit model mutation.

The method allowlist is necessary but not sufficient. Exact package-owned model definitions, reserved aliases, native resources, platform support, installed state, and exclusive mutation policy remain authoritative.

Raw versus normalized behavior

The module intentionally has two levels:

Streaming, cancellation, and uncertain mutation state

generate, chat, pull, push, and create accept stream controls through the bridge forms documented on their detailed pages. Core cooperatively cancels admitted inference methods where documented. For pull, push, create, selection, settings, or service mutation, abort/timeout/page teardown can stop renderer observation without proving host work rolled back.

After an uncertain model mutation, refresh the relevant raw inventory, selection(), settings(), serviceSettings(), or localAI.status() before retrying. Do not stack a second mutation merely because the renderer timed out.

Behavioral testing

The SDK behavior suite uses an explicit fake Arcane.ollama to prove:

• every wrapper forwards the exact argument objects and provider-native result;
• stream options and signals are not rewritten;
• bridge absence throws ARCANE_OLLAMA_UNAVAILABLE before provider work;
• readiness() returns frozen success/failure snapshots;
• generateText() and chatText() use the pinned String(value || '') behavior: truthy nonstrings stringify and falsy nonstrings become empty;
• unload() sends exactly {model, prompt: "", keep_alive: 0}.

Those tests prove the shipped renderer module. Live Core dispatch, cancellation, ArcaneOllama health, real model pulls, GPU admission, service restart, and rollback remain Arcane OS host/integration evidence.

Deep implementation path: Arcane Ollama protocol.