@agent-native/core 0.185.0 → 0.186.0-nightly-20260923163746

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 9786
+- template files: 9787

package/corpus/templates/clips/actions/finalize-recording.ts

@@ -323,8 +323,35 @@ async function failStoredButUnservableRecording(params: {
         eq(schema.recordings.status, "processing"),
       ),
     )
-    .returning({ id: schema.recordings.id });
+    .returning({
+      id: schema.recordings.id,
+      uploadAttemptId: schema.recordings.uploadAttemptId,
+    });
   if (failed.length !== 1) return false;
+  try {
+    track(
+      "clips_upload_blocking_failure",
+      {
+        app: "clips",
+        template: "clips",
+        surface: "media_verification",
+        stage: "media_verification",
+        outcome: "failed",
+        failure_type: "media_verification",
+        failure_code: "media_verification_failed",
+        output_id: id,
+        output_type: "clip",
+        recording_id: id,
+        recording_attempt_id: id,
+        ...(failed[0]?.uploadAttemptId
+          ? { upload_attempt_id: failed[0].uploadAttemptId }
+          : {}),
+      },
+      { userId: ownerEmail },
+    );
+  } catch {
+    // coercion-ok: analytics is best-effort and must not change media recovery behavior.
+  }
   const uploadStateRaw = await readAppState(`recording-upload-${id}`).catch(
     () => null,
   );
@@ -605,6 +632,7 @@ async function markRecordingReady(params: {
   finalHeight: number;
   finalHasAudio: boolean;
   finalHasCamera: boolean;
+  recordingAttemptId?: string | null;
   existingTitle: string;
   // Whether a seekable rewrite (MP4 faststart / WebM Cues remux) was already
   // applied to the uploaded bytes. When false, a best-effort background repair
@@ -623,6 +651,7 @@ async function markRecordingReady(params: {
     finalHeight,
     finalHasAudio,
     finalHasCamera,
+    recordingAttemptId,
     existingTitle,
     seekableApplied,
   } = params;
@@ -716,6 +745,8 @@ async function markRecordingReady(params: {
       template_name: "clips",
       output_id: id,
       output_type: "clip",
+      recording_attempt_id: id,
+      ...(recordingAttemptId ? { upload_attempt_id: recordingAttemptId } : {}),
       duration_s: Math.round(finalDurationMs / 1000),
       video_format: videoFormat,
       has_audio: finalHasAudio,
@@ -864,6 +895,7 @@ async function retryPendingMediaVerification(params: {
   const db = getDb();
   const [recording] = await db
     .select({
+      uploadAttemptId: schema.recordings.uploadAttemptId,
       status: schema.recordings.status,
       videoUrl: schema.recordings.videoUrl,
       editsJson: schema.recordings.editsJson,
@@ -919,6 +951,7 @@ async function retryPendingMediaVerification(params: {
       finalHeight: candidate.finalHeight,
       finalHasAudio: candidate.finalHasAudio,
       finalHasCamera: candidate.finalHasCamera,
+      recordingAttemptId: recording.uploadAttemptId,
       seekableApplied: candidate.seekableApplied,
     });
     if (result.status === "ready" && result.transitionedToReady) {
@@ -1196,6 +1229,7 @@ export default defineAction({
         finalHeight,
         finalHasAudio,
         finalHasCamera,
+        recordingAttemptId: existing.uploadAttemptId,
         existingTitle: existing.title,
       };
 

package/corpus/templates/clips/app/components/player/delete-recording-menu.tsx

@@ -105,7 +105,11 @@ export function RecordingOptionsMenu({
         </DropdownMenuTrigger>
         <DropdownMenuContent
           align="end"
-          className={showCustomItems ? "w-64" : "w-44"}
+          className={
+            showCustomItems
+              ? "w-64 max-h-[var(--radix-dropdown-menu-content-available-height)] overflow-x-hidden overflow-y-auto"
+              : "w-44"
+          }
           onCloseAutoFocus={(event) => {
             // Opening the AlertDialog while this menu is still tearing down
             // leaves `pointer-events: none` stuck on <body>: two dismissable

package/corpus/templates/clips/app/components/recorder/recorder-engine.ts

@@ -399,12 +399,27 @@ function isRetryableChunkUploadStatus(status: number): boolean {
 }
 
 function trackClipUploadBlockingFailure(props: Record<string, unknown>): void {
+  const recordingId =
+    typeof props.recordingId === "string" ? props.recordingId : undefined;
+  const uploadAttemptId =
+    typeof props.uploadAttemptId === "string"
+      ? props.uploadAttemptId
+      : undefined;
   try {
     trackEvent("clips_upload_blocking_failure", {
+      ...props,
       app: "clips",
       template: "clips",
       surface: "web_recorder",
-      ...props,
+      output_id: recordingId,
+      output_type: "clip",
+      recording_id: recordingId,
+      recording_attempt_id: recordingId,
+      ...(uploadAttemptId ? { upload_attempt_id: uploadAttemptId } : {}),
+      failure_code:
+        typeof props.failureKind === "string"
+          ? props.failureKind
+          : "upload_failed",
     });
   } catch {
     // Analytics should never change recording behavior.
@@ -2623,6 +2638,7 @@ export class RecorderEngine {
         stage: "chunk_upload",
         failureKind: "no_response",
         recordingId: this.opts.recordingId,
+        uploadAttemptId: this.uploadAttemptId,
         chunkIndex: index,
         isFinal: extra.isFinal === true,
         chunkBytes: blob.size,
@@ -2663,6 +2679,7 @@ export class RecorderEngine {
         stage: "chunk_upload",
         failureKind: "http_error",
         recordingId: this.opts.recordingId,
+        uploadAttemptId: this.uploadAttemptId,
         chunkIndex: index,
         isFinal: extra.isFinal === true,
         httpStatus: res.status,

package/corpus/templates/clips/app/routes/_app.r.$recordingId.tsx

@@ -2347,7 +2347,7 @@ export default function RecordingPage() {
               <DropdownMenuSubTrigger>
                 {t("recordingPage.enhanceRecording")}
               </DropdownMenuSubTrigger>
-              <DropdownMenuSubContent className="w-56">
+              <DropdownMenuSubContent className="w-56 max-h-[var(--radix-dropdown-menu-content-available-height)] overflow-x-hidden overflow-y-auto">
                 <DropdownMenuItem
                   disabled={requestTranscript.isPending}
                   onSelect={() =>
@@ -2380,7 +2380,7 @@ export default function RecordingPage() {
               <DropdownMenuSubTrigger>
                 {t("recordingPage.createFromClip")}
               </DropdownMenuSubTrigger>
-              <DropdownMenuSubContent className="w-64">
+              <DropdownMenuSubContent className="w-64 max-h-[var(--radix-dropdown-menu-content-available-height)] overflow-x-hidden overflow-y-auto">
                 {WORKFLOW_MENU_ITEMS.map((item) => {
                   const menuItem = (
                     <DropdownMenuItem

package/corpus/templates/clips/app/routes/record.tsx

@@ -2112,6 +2112,7 @@ export default function RecordRoute() {
         app_name: "clips",
         template_name: "clips",
         output_id: pendingRef.current?.id,
+        recording_attempt_id: pendingRef.current?.id,
         capture_type:
           recordingMode === "camera"
             ? "camera"

package/corpus/templates/clips/changelog/2026-09-23-long-recording-menus-scroll-within-the-visible-space-so-ever.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-23
+---
+
+Long recording menus scroll within the visible space so every action stays reachable.

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -180,6 +180,8 @@ function expectedDataChunksForFinalPost(
 
 function trackUploadBlockingFailure(
   ownerEmail: string,
+  recordingId: string,
+  attemptId: string | null,
   properties: Record<string, unknown>,
 ): void {
   try {
@@ -189,6 +191,14 @@ function trackUploadBlockingFailure(
         app: "clips",
         template: "clips",
         surface: "server_upload",
+        output_id: recordingId,
+        output_type: "clip",
+        recording_id: recordingId,
+        // Keep this stable for the recording lifecycle; upload_attempt_id
+        // disambiguates resumable retries without breaking the join to start.
+        recording_attempt_id: recordingId,
+        ...(attemptId ? { upload_attempt_id: attemptId } : {}),
+        failure_code: properties.failure_code ?? properties.failure_type,
         ...properties,
       },
       { userId: ownerEmail },
@@ -693,7 +703,7 @@ export async function handleRecordingChunk(
         });
         if ((result as any)?.status === "failed") {
           const failure = finalizeResultFailure(result);
-          trackUploadBlockingFailure(ownerEmail, {
+          trackUploadBlockingFailure(ownerEmail, recordingId, attemptId, {
             stage: "finalize_recording",
             outcome: failure.outcome,
             failure_type: failure.failure_type,
@@ -812,7 +822,7 @@ export async function handleRecordingChunk(
             return acceptedProcessingResponse(event, recordingId, pendingState);
           }
         }
-        trackUploadBlockingFailure(ownerEmail, {
+        trackUploadBlockingFailure(ownerEmail, recordingId, attemptId, {
           stage: "finalize_recording",
           outcome: "failed",
           failure_type: classifyTrackingFailure(err),
@@ -1273,7 +1283,7 @@ async function handleResumableChunk(
     );
     if ((result as any)?.status === "failed") {
       const failure = finalizeResultFailure(result);
-      trackUploadBlockingFailure(ownerEmail, {
+      trackUploadBlockingFailure(ownerEmail, recordingId, attemptId, {
         stage: "finalize_recording",
         outcome: failure.outcome,
         failure_type: failure.failure_type,
@@ -1380,7 +1390,7 @@ async function handleResumableChunk(
       }
     }
 
-    trackUploadBlockingFailure(ownerEmail, {
+    trackUploadBlockingFailure(ownerEmail, recordingId, attemptId, {
       stage: "finalize_recording",
       outcome: "failed",
       failure_type: classifyTrackingFailure(err),

package/dist/agent/engine/openai-compatible-endpoint.d.ts

@@ -4,3 +4,10 @@ export declare const OLLAMA_BASE_URL_ENV_VAR = "OLLAMA_BASE_URL";
 export declare function isCustomOpenAiBaseUrl(value: string | undefined): boolean;
 export declare function normalizeProviderBaseUrl(value: string): string;
 export declare function normalizeOpenAiBaseUrl(value: string): string;
+/**
+ * Ollama's own API has no `/v1` path — that suffix only applies to its
+ * OpenAI-compatibility shim, which this integration doesn't use. Docs for
+ * other tools commonly show `/v1`, so users copy-paste it in; strip it
+ * silently rather than making them notice and remove it themselves.
+ */
+export declare function stripOllamaV1Suffix(value: string): string;

package/dist/agent/engine/openai-compatible-endpoint.js

@@ -28,3 +28,12 @@ export function normalizeProviderBaseUrl(value) {
 export function normalizeOpenAiBaseUrl(value) {
     return normalizeProviderBaseUrl(value);
 }
+/**
+ * Ollama's own API has no `/v1` path — that suffix only applies to its
+ * OpenAI-compatibility shim, which this integration doesn't use. Docs for
+ * other tools commonly show `/v1`, so users copy-paste it in; strip it
+ * silently rather than making them notice and remove it themselves.
+ */
+export function stripOllamaV1Suffix(value) {
+    return value.replace(/\/v1$/i, "");
+}

package/dist/agent/engine/provider-endpoint-validation.d.ts

@@ -1,9 +1,16 @@
 /**
  * Validate a provider endpoint before a server-side model request can use it.
  * `allowPrivate` is reserved for operator-owned deployment configuration; it
- * must never be enabled for a user- or agent-supplied URL.
+ * must never be enabled for a user- or agent-supplied URL. `allowLocalOllama`
+ * additionally requires the caller to have already established this is a
+ * trusted, self-hosted context (see `isTrustedSelfHostedRuntime`) — it is
+ * never safe to grant purely from the endpoint value itself. `isOllama` says
+ * this endpoint is for Ollama specifically (independent of trust level), so a
+ * copy-pasted trailing `/v1` — meaningless for Ollama's own API — is silently
+ * removed instead of left to confuse the address that gets saved and used.
  */
 export declare function validateProviderBaseUrl(value: string, options?: {
     allowPrivate?: boolean;
     allowLocalOllama?: boolean;
+    isOllama?: boolean;
 }): Promise<string>;

package/dist/agent/engine/provider-endpoint-validation.js

@@ -1,20 +1,57 @@
 import { isBlockedExtensionUrlWithDns } from "../../extensions/url-safety.js";
-import { normalizeProviderBaseUrl } from "./openai-compatible-endpoint.js";
-function isLoopbackOllamaEndpoint(value) {
-    const hostname = new URL(value).hostname.toLowerCase();
-    return (hostname === "localhost" ||
-        hostname === "127.0.0.1" ||
-        hostname === "::1" ||
-        hostname === "[::1]");
+import { normalizeProviderBaseUrl, stripOllamaV1Suffix, } from "./openai-compatible-endpoint.js";
+function isPrivateIpv4Lan(a, b, c, d) {
+    if (![a, b, c, d].every((part) => part >= 0 && part <= 255))
+        return false;
+    if (a === 127)
+        return true; // loopback
+    if (a === 10)
+        return true; // 10.0.0.0/8
+    if (a === 172 && b >= 16 && b <= 31)
+        return true; // 172.16.0.0/12
+    if (a === 192 && b === 168)
+        return true; // 192.168.0.0/16
+    return false;
+}
+/**
+ * True for hosts an Ollama server commonly runs on: loopback, or an RFC1918
+ * LAN address such as `192.168.1.123`. Deliberately narrower than the
+ * generic SSRF private-address check in `url-safety.ts` — link-local
+ * addresses (169.254.x.x, which also covers the cloud metadata endpoint) and
+ * other reserved ranges stay blocked even for Ollama. Only literal IPs and
+ * `localhost` are recognized; an arbitrary hostname that merely resolves to
+ * a LAN address is not, so this never depends on a DNS lookup.
+ */
+function isLocalNetworkOllamaEndpoint(value) {
+    const hostname = new URL(value).hostname
+        .toLowerCase()
+        .replace(/^\[|\]$/g, "");
+    if (hostname === "localhost" || hostname === "::1")
+        return true;
+    const parts = hostname.split(".");
+    if (parts.length === 4 && parts.every((p) => /^\d+$/.test(p))) {
+        const [a, b, c, d] = parts.map(Number);
+        return isPrivateIpv4Lan(a, b, c, d);
+    }
+    return false;
 }
 /**
  * Validate a provider endpoint before a server-side model request can use it.
  * `allowPrivate` is reserved for operator-owned deployment configuration; it
- * must never be enabled for a user- or agent-supplied URL.
+ * must never be enabled for a user- or agent-supplied URL. `allowLocalOllama`
+ * additionally requires the caller to have already established this is a
+ * trusted, self-hosted context (see `isTrustedSelfHostedRuntime`) — it is
+ * never safe to grant purely from the endpoint value itself. `isOllama` says
+ * this endpoint is for Ollama specifically (independent of trust level), so a
+ * copy-pasted trailing `/v1` — meaningless for Ollama's own API — is silently
+ * removed instead of left to confuse the address that gets saved and used.
  */
 export async function validateProviderBaseUrl(value, options = {}) {
-    const normalized = normalizeProviderBaseUrl(value);
-    const allowLocalOllama = options.allowLocalOllama === true && isLoopbackOllamaEndpoint(normalized);
+    let normalized = normalizeProviderBaseUrl(value);
+    if (options.isOllama)
+        normalized = stripOllamaV1Suffix(normalized);
+    const allowLocalOllama = options.allowLocalOllama === true &&
+        isLocalNetworkOllamaEndpoint(normalized);
     if (!options.allowPrivate &&
         !allowLocalOllama &&
         (await isBlockedExtensionUrlWithDns(normalized))) {

package/dist/agent/engine/registry.js

@@ -12,7 +12,7 @@ import { getAppConfig } from "../../app-config/index.js";
 import { getUserLabs } from "../../labs/store.js";
 import { BUILDER_OAUTH_SCOPE, hasBuilderOAuthSession, resolveBuilderOAuthRequestAccess, } from "../../server/builder-oauth.js";
 import { hasChatGPTSubscriptionCredential } from "../../server/chatgpt-subscription-oauth.js";
-import { assertCredentialStoreReadable, canUseDeployCredentialFallbackForRequest, getBuilderCredentialAuthFailure, getProviderCredentialAuthFailure, prefetchSecrets, readDeployCredentialEnv, resolveBuilderCredentialsDetailed, resolveBuilderGatewayCredentialsDetailed, resolveSecret, } from "../../server/credential-provider.js";
+import { assertCredentialStoreReadable, canUseDeployCredentialFallbackForRequest, getBuilderCredentialAuthFailure, getProviderCredentialAuthFailure, isTrustedSelfHostedRuntime, prefetchSecrets, readDeployCredentialEnv, resolveBuilderCredentialsDetailed, resolveBuilderGatewayCredentialsDetailed, resolveSecret, } from "../../server/credential-provider.js";
 import { getRequestOrgId, getRequestContext, getRequestUserEmail, } from "../../server/request-context.js";
 import { getSetting } from "../../settings/store.js";
 import { getAgentAppModelDefaultForCurrentRequest } from "../app-model-defaults.js";
@@ -625,11 +625,13 @@ async function resolveProviderBaseUrl(envVar) {
     const deployValue = canUseDeployCredentialFallbackForRequest(envVar)
         ? readDeployCredentialEnv(envVar)
         : undefined;
+    const isOllama = envVar === OLLAMA_BASE_URL_ENV_VAR;
     if (!raw) {
         if (!deployValue)
             return undefined;
         return validateProviderBaseUrl(deployValue, {
             allowPrivate: true,
+            isOllama,
         });
     }
     return raw
@@ -639,8 +641,8 @@ async function resolveProviderBaseUrl(envVar) {
             // allowance as the explicit deploy-only branch above without extending
             // it to user-, org-, or workspace-scoped endpoint values.
             allowPrivate: deployValue !== undefined && raw === deployValue,
-            allowLocalOllama: envVar === OLLAMA_BASE_URL_ENV_VAR &&
-                process.env.NODE_ENV !== "production",
+            allowLocalOllama: isOllama && isTrustedSelfHostedRuntime(),
+            isOllama,
         })
         : undefined;
 }
@@ -815,9 +817,10 @@ async function engineCreateConfigForEntry(entry, apiKey, extra, credentialResolu
     }
     if (entry.name === "ai-sdk:openai" || entry.name === "ai-sdk:ollama") {
         if (typeof safeExtra.baseURL === "string" && safeExtra.baseUrl == null) {
+            const isOllama = entry.name === "ai-sdk:ollama";
             safeExtra.baseUrl = await validateProviderBaseUrl(safeExtra.baseURL, {
-                allowLocalOllama: entry.name === "ai-sdk:ollama" &&
-                    process.env.NODE_ENV !== "production",
+                allowLocalOllama: isOllama && isTrustedSelfHostedRuntime(),
+                isOllama,
             });
         }
         if (safeExtra.baseUrl == null) {

package/dist/cli/skills.d.ts

@@ -189,6 +189,7 @@ export type SkillsCatalogMode = "agent-native" | "all";
 export interface PublicSkillCatalogEntry {
     name: string;
     description?: string;
+    installerGroup?: string;
 }
 interface ConnectSpinner {
     start(message?: string): void;
@@ -263,7 +264,9 @@ interface SkillsClientPromptContext {
     installsMcp: boolean;
 }
 interface SkillsTargetPromptContext {
+    message?: string;
     initialTargets: string[];
+    required?: boolean;
     options: Array<{
         value: string;
         label: string;

package/dist/cli/skills.js

@@ -1808,6 +1808,7 @@ function publicSkillEntries(options) {
         .map((entry) => ({
         name: entry.name.trim().toLowerCase(),
         description: entry.description,
+        installerGroup: entry.installerGroup?.trim().toLowerCase(),
     }))
         .filter((entry) => {
         if (!entry.name || isKnownSkill(entry.name) || seen.has(entry.name)) {
@@ -1822,11 +1823,16 @@ function publicSkillNames(options) {
     return new Set(publicSkillEntries(options).map((entry) => entry.name));
 }
 function publicSkillPromptOptions(options) {
-    return publicSkillEntries(options).map((entry) => ({
-        value: entry.name,
-        label: entry.name,
-        hint: entry.description ?? "Public skill from the BuilderIO skills catalog.",
-    }));
+    return publicSkillEntries(options).map((entry) => {
+        const description = entry.description ?? "Public skill from the BuilderIO skills catalog.";
+        return {
+            value: entry.name,
+            label: entry.name,
+            hint: entry.installerGroup === entry.name
+                ? `${description} Select to choose the full group or a subset.`
+                : description,
+        };
+    });
 }
 function skillPromptOptions(options = {}) {
     return [
@@ -1999,11 +2005,12 @@ async function promptForUpdateInstructions() {
 async function promptForSkills(context) {
     const clack = await import("@clack/prompts");
     const result = await clack.multiselect({
-        message: "Which Agent-Native skills do you want to install?\n" +
-            "  (space toggles, enter confirms)",
+        message: context.message ??
+            "Which Agent-Native skills do you want to install?\n" +
+                "  (space toggles, enter confirms)",
         options: context.options,
         initialValues: context.initialTargets,
-        required: true,
+        required: context.required ?? true,
     });
     if (clack.isCancel(result)) {
         clack.cancel("Cancelled.");
@@ -2149,7 +2156,36 @@ async function resolveSkillTargets(parsed, options) {
     });
     if (!selected || selected.length === 0)
         return null;
-    return resolveSelectedSkillTargets(selected, options);
+    const publicEntries = publicSkillEntries(options);
+    const selectedTargets = new Set(selected);
+    for (const group of publicEntries.filter((entry) => entry.installerGroup === entry.name && selected.includes(entry.name))) {
+        const members = publicEntries.filter((entry) => entry.installerGroup === group.name && entry.name !== group.name);
+        if (members.length === 0)
+            continue;
+        const groupLabel = group.name.replace(/^./, (character) => character.toUpperCase());
+        const groupSelection = await prompt({
+            message: `Which ${groupLabel} skills do you want to install?\n` +
+                "  (all selected; deselect any you want to skip)",
+            initialTargets: members.map((entry) => entry.name),
+            required: false,
+            options: members.map((entry) => ({
+                value: entry.name,
+                label: entry.name,
+                hint: entry.description ??
+                    "Public skill from the BuilderIO skills catalog.",
+            })),
+        });
+        if (!groupSelection)
+            return null;
+        const memberNames = new Set(members.map((entry) => entry.name));
+        for (const memberName of memberNames)
+            selectedTargets.delete(memberName);
+        for (const memberName of groupSelection) {
+            if (memberNames.has(memberName))
+                selectedTargets.add(memberName);
+        }
+    }
+    return resolveSelectedSkillTargets([...selectedTargets], options);
 }
 export function parseSkillsArgs(argv) {
     const first = argv[0];

package/dist/client/agent-engine-key.d.ts

@@ -53,6 +53,13 @@ export declare function saveAgentEngineApiKey({ provider, key, apiKey, scope, }:
  * endpoint URLs. Values are stored server-side in scoped secrets.
  */
 export declare function saveAgentEngineProviderSettings({ provider, key, apiKey, baseUrl, clearBaseUrl, }: SaveAgentEngineProviderSettingsOptions): Promise<void>;
+/**
+ * List the models an Ollama server actually has installed, via its native
+ * `/api/tags` endpoint. Pass `baseUrl` to check a server before it's saved
+ * (e.g. while the user is still typing the endpoint); omit it to use the
+ * saved endpoint. Throws a readable Error if the server can't be reached.
+ */
+export declare function fetchOllamaModels(baseUrl?: string): Promise<string[]>;
 /**
  * Select the provider and model for the next conversation. This is separate
  * from saving credentials so keyless local providers such as Ollama can use

package/dist/client/agent-engine-key.js

@@ -201,6 +201,43 @@ export async function saveAgentEngineProviderSettings({ provider, key, apiKey, b
     }
     dispatchConfiguredChanged();
 }
+/**
+ * List the models an Ollama server actually has installed, via its native
+ * `/api/tags` endpoint. Pass `baseUrl` to check a server before it's saved
+ * (e.g. while the user is still typing the endpoint); omit it to use the
+ * saved endpoint. Throws a readable Error if the server can't be reached.
+ */
+export async function fetchOllamaModels(baseUrl) {
+    const trimmed = baseUrl?.trim() ?? "";
+    const path = trimmed
+        ? `/_agent-native/agent-engine/ollama-models?baseUrl=${encodeURIComponent(trimmed)}`
+        : "/_agent-native/agent-engine/ollama-models";
+    const response = await fetch(agentNativePath(path), {
+        credentials: "include",
+    });
+    const text = await response.text();
+    let payload;
+    try {
+        payload = text.trim() ? JSON.parse(text) : undefined;
+    }
+    catch {
+        throw new Error(`Could not read the Ollama models response (HTTP ${response.status}).`);
+    }
+    if (!response.ok) {
+        const message = payload &&
+            typeof payload === "object" &&
+            typeof payload.error === "string"
+            ? payload.error
+            : `Could not list Ollama models (HTTP ${response.status}).`;
+        throw new Error(message);
+    }
+    const models = payload && typeof payload === "object"
+        ? payload.models
+        : undefined;
+    return Array.isArray(models)
+        ? models.filter((model) => typeof model === "string")
+        : [];
+}
 /**
  * Select the provider and model for the next conversation. This is separate
  * from saving credentials so keyless local providers such as Ollama can use

package/dist/client/agent-provider-catalog.js

@@ -72,7 +72,7 @@ export const AGENT_PROVIDER_CATALOG = PROVIDER_ORDER.map((id) => {
             ? {
                 supportsEndpoint: true,
                 endpointPlaceholder: isOllama
-                    ? "http://localhost:11434"
+                    ? "http://localhost:11434 or local network address like http://192.168.1.123:11434"
                     : "https://gateway.example/v1",
             }
             : {}),