tinyhumansai/openhuman · error · Error

Local model runtime is unavailable in this core build…

Error message

Local model runtime is unavailable in this core build. Restart app after updating to the latest build.

What it means

openhumanLocalAiStatus calls openhuman.inference_status over relay_http_rpc and inspects the failure: when the core's error message contains 'unknown method: openhuman.inference_status' it re-throws this friendly 'Local model runtime is unavailable in this core build' error. The 'unknown method: ' prefix is the core dispatcher's method_not_found signal (UNKNOWN_METHOD_PREFIX in src/core/dispatch.rs, mirrored in coreRpcClient.ts:126) — a permanent transport-boundary version skew, not a transient fault. It means the running core binary genuinely does not expose the inference status RPC: an older core than the UI bundle, a staged update that updated one half, or a slim/gated build without the inference domain.

Solutions

Follow the message: update to the latest build and restart the app so the core binary and UI bundle match.
Verify the running core actually exposes the method: GET /schema on the core (or the about/health RPC) and check for openhuman.inference_status.
If building the core yourself, enable the inference surface (product feature set / appropriate DomainSet) instead of a slim profile.
If the mismatch is expected (embedded host), catch this error and hide/disable the local-AI settings UI rather than retrying — method_not_found never self-heals.

Example fix

// before
const status = (await openhumanLocalAiStatus()).result;

// after
try {
  const status = (await openhumanLocalAiStatus()).result;
  renderLocalAiPanel(status);
} catch (e) {
  if (e instanceof Error && e.message.includes('unavailable in this core build')) {
    renderUpgradeNotice(); // permanent — do not poll/retry
  } else throw e;
}

Defensive patterns

Strategy: try-catch

Validate before calling

// Before calling, confirm the running core exposes the method (permanent check):
import { callCoreRpc } from '../services/coreRpcClient';

const supportsInferenceStatus = async (): Promise<boolean> => {
  try {
    await callCoreRpc({ method: 'openhuman.inference_status' });
    return true;
  } catch (err) {
    return !(err instanceof Error && err.message.includes('unknown method: openhuman.inference_status'));
  }
};

Type guard

const isInferenceUnavailableError = (e: unknown): boolean =>
  e instanceof Error && e.message.includes('Local model runtime is unavailable in this core build');

Try / catch

try {
  const status = (await openhumanLocalAiStatus()).result;
} catch (e) {
  if (e instanceof Error && e.message.includes('unavailable in this core build')) {
    // method_not_found — permanent version/gate skew: hide local-AI UI, prompt update, do NOT retry
  } else {
    throw e;
  }
}

Prevention

Treat method_not_found as permanent: stop polling instead of retrying (#5157 pattern).
Branch on CoreRpcError.kind === 'method_not_found' from coreRpcClient rather than raw message regexes.
Keep UI bundle and core binary in lockstep — complete app updates and restart rather than hot-swapping one half.
Custom/slim core builds must include the inference surface before driving the full UI.
Verify with GET /schema on the core when skew is suspected.

When it happens

Trigger: UI bundle newer than the embedded core (core updated but app restarted into the old binary, or vice versa); a core compiled with the inference surface gated out (DomainSet/feature-gated or kernel-profile build); a rolled-back core binary with a newer frontend. Any call to openhumanLocalAiStatus() in that state.

Common situations: Partial app update where the web layer and Rust core are out of sync; self-compiled or slim core builds (cargo build with a reduced feature set) driving the full UI; embedded hosts using DomainSet presets that omit the inference domain; local model settings screen polling status on first render.

Related errors

AI-assisted analysis of tinyhumansai/openhuman@7491200858 (2026-08-17). Data as JSON: /api/errors/24d729d9ffd308d9. Report an issue: GitHub.

Appendix: source

Thrown at app/src/utils/tauriCommands/localAi.ts:246

): Promise<CommandResponse<string>> {
  if (!isTauri()) {
    throw new Error('Not running in Tauri');
  }
  return await callCoreRpc<CommandResponse<string>>({
    method: 'openhuman.agent_chat',
    params: { message, model_override: modelOverride, temperature },
  });
}

export async function openhumanLocalAiStatus(): Promise<CommandResponse<LocalAiStatus>> {
  try {
    return await callCoreRpc<CommandResponse<LocalAiStatus>>({
      method: 'openhuman.inference_status',
    });
  } catch (err) {
    const message = tauriErrorMessage(err);
    if (message.includes('unknown method: openhuman.inference_status')) {
      throw new Error(
        'Local model runtime is unavailable in this core build. Restart app after updating to the latest build.'
      );
    }
    throw new Error(message);
  }
}

export async function openhumanLocalAiSummarize(
  text: string,
  maxTokens?: number
): Promise<CommandResponse<string>> {
  return await callCoreRpc<CommandResponse<string>>({
    method: 'openhuman.inference_summarize',
    params: { text, max_tokens: maxTokens },
  });
}

export async function openhumanLocalAiPrompt(

View on GitHub (pinned to 7491200858)