@xopcai/xopc 0.0.163 → 0.0.164

package/dist/src/providers/model-catalog-store.d.ts

@@ -1,62 +1,24 @@
-import { z } from 'zod';
-declare const CatalogModelSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    availability: z.ZodEnum<{
-        available: "available";
-        unavailable: "unavailable";
-    }>;
-    maxOutputTokens: z.ZodNullable<z.ZodNumber>;
-}, z.core.$strip>;
-declare const CatalogSourceSchema: z.ZodObject<{
-    providerId: z.ZodString;
-    baseUrl: z.ZodString;
-    api: z.ZodEnum<{
-        "openai-completions": "openai-completions";
-        "openai-responses": "openai-responses";
-    }>;
-    etag: z.ZodNullable<z.ZodString>;
-    recommendedModel: z.ZodNullable<z.ZodString>;
-    lastSuccessAt: z.ZodNumber;
-    models: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        availability: z.ZodEnum<{
-            available: "available";
-            unavailable: "unavailable";
-        }>;
-        maxOutputTokens: z.ZodNullable<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const ModelCatalogSchema: z.ZodObject<{
-    sources: z.ZodRecord<z.ZodString, z.ZodObject<{
-        providerId: z.ZodString;
-        baseUrl: z.ZodString;
-        api: z.ZodEnum<{
-            "openai-completions": "openai-completions";
-            "openai-responses": "openai-responses";
-        }>;
-        etag: z.ZodNullable<z.ZodString>;
-        recommendedModel: z.ZodNullable<z.ZodString>;
-        lastSuccessAt: z.ZodNumber;
-        models: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodString;
-            availability: z.ZodEnum<{
-                available: "available";
-                unavailable: "unavailable";
-            }>;
-            maxOutputTokens: z.ZodNullable<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type CatalogModel = z.infer<typeof CatalogModelSchema>;
-export type CatalogSource = z.infer<typeof CatalogSourceSchema>;
-export type ModelCatalogSnapshot = z.infer<typeof ModelCatalogSchema>;
+export interface CatalogModel {
+    id: string;
+    name: string;
+    availability: 'available' | 'unavailable';
+    maxOutputTokens: number | null;
+}
+export interface CatalogSource {
+    providerId: string;
+    baseUrl: string;
+    api: 'openai-completions' | 'openai-responses';
+    etag: string | null;
+    recommendedModel: string | null;
+    lastSuccessAt: number;
+    models: CatalogModel[];
+}
+export interface ModelCatalogSnapshot {
+    sources: Record<string, CatalogSource>;
+}
 export type AvailableCatalogModel = Omit<CatalogModel, 'availability'>;
 export declare class ModelCatalogStore {
-    private readonly path;
-    constructor(path?: string);
+    private sources;
     load(): ModelCatalogSnapshot;
     getSource(sourceId: string): CatalogSource | undefined;
     saveSource(sourceId: string, source: CatalogSource): void;
@@ -65,7 +27,7 @@ export declare class ModelCatalogStore {
         addedCount: number;
         unavailableCount: number;
     };
+    private cloneSource;
 }
 export declare function getModelCatalogStore(): ModelCatalogStore;
 export declare function resetModelCatalogStore(): void;
-export {};

package/dist/src/providers/model-catalog-store.js

@@ -1,11 +1,4 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-import { init_write_file_atomic, writeTextAtomicSync } from "../infra/write-file-atomic.js";
-import { join } from "node:path";
-import { existsSync, readFileSync } from "node:fs";
-import { z } from "zod";
 //#region src/providers/model-catalog-store.ts
 function getModelCatalogStore() {
 	globalModelCatalogStore ??= new ModelCatalogStore();
@@ -14,65 +7,27 @@ function getModelCatalogStore() {
 function resetModelCatalogStore() {
 	globalModelCatalogStore = void 0;
 }
-var log, CatalogModelSchema, CatalogSourceSchema, ModelCatalogSchema, ModelCatalogStore, globalModelCatalogStore;
+var ModelCatalogStore, globalModelCatalogStore;
 var init_model_catalog_store = __esmMin((() => {
-	init_paths_state();
-	init_write_file_atomic();
-	init_logger();
-	log = createLogger("ModelCatalogStore");
-	CatalogModelSchema = z.object({
-		id: z.string().min(1),
-		name: z.string().min(1),
-		availability: z.enum(["available", "unavailable"]),
-		maxOutputTokens: z.number().positive().nullable()
-	});
-	CatalogSourceSchema = z.object({
-		providerId: z.string().min(1),
-		baseUrl: z.string().url(),
-		api: z.enum(["openai-completions", "openai-responses"]),
-		etag: z.string().nullable(),
-		recommendedModel: z.string().nullable(),
-		lastSuccessAt: z.number().int().nonnegative(),
-		models: z.array(CatalogModelSchema)
-	});
-	ModelCatalogSchema = z.object({ sources: z.record(z.string(), CatalogSourceSchema) });
 	ModelCatalogStore = class {
-		constructor(path = join(resolveStateDir(), "model-catalog.json")) {
-			this.path = path;
-		}
+		sources = {};
 		load() {
-			if (!existsSync(this.path)) return { sources: {} };
-			try {
-				const parsed = ModelCatalogSchema.safeParse(JSON.parse(readFileSync(this.path, "utf8")));
-				if (parsed.success) return parsed.data;
-				log.warn({
-					path: this.path,
-					errorMessage: parsed.error.message
-				}, "Ignoring invalid model catalog snapshot");
-			} catch (err) {
-				log.warn({
-					err,
-					path: this.path
-				}, "Ignoring unreadable model catalog snapshot");
-			}
-			return { sources: {} };
+			return { sources: Object.fromEntries(Object.entries(this.sources).map(([id, source]) => [id, this.cloneSource(source)])) };
 		}
 		getSource(sourceId) {
-			return this.load().sources[sourceId];
+			const source = this.sources[sourceId];
+			return source ? this.cloneSource(source) : void 0;
 		}
 		saveSource(sourceId, source) {
-			const current = this.load();
-			const next = ModelCatalogSchema.parse({ sources: {
-				...current.sources,
-				[sourceId]: source
-			} });
-			writeTextAtomicSync(this.path, `${JSON.stringify(next, null, 2)}\n`, { mode: 384 });
+			this.sources = {
+				...this.sources,
+				[sourceId]: this.cloneSource(source)
+			};
 		}
 		removeSource(sourceId) {
-			const current = this.load();
-			if (!current.sources[sourceId]) return false;
-			const { [sourceId]: _removed, ...sources } = current.sources;
-			writeTextAtomicSync(this.path, `${JSON.stringify({ sources }, null, 2)}\n`, { mode: 384 });
+			if (!this.sources[sourceId]) return false;
+			const { [sourceId]: _removed, ...sources } = this.sources;
+			this.sources = sources;
 			return true;
 		}
 		replaceSourceModels(sourceId, source, models) {
@@ -95,6 +50,12 @@ var init_model_catalog_store = __esmMin((() => {
 				unavailableCount: unavailable.length
 			};
 		}
+		cloneSource(source) {
+			return {
+				...source,
+				models: source.models.map((model) => ({ ...model }))
+			};
+		}
 	};
 }));
 //#endregion

package/dist/src/providers/model-catalog-sync-service.d.ts

@@ -2,7 +2,7 @@ import type { Config } from '../config/schema.js';
 import { type ModelsJsonConfig } from '../config/models-json.js';
 import { type ModelCatalogStore } from './model-catalog-store.js';
 import { discoverProviderModels } from './model-discovery.js';
-import { XopcCloudConnectionService } from './xopc-cloud-connection.js';
+import { XopcCloudModelSource } from './xopc-cloud-model-source.js';
 export interface ModelCatalogSyncStatus {
     running: boolean;
     refreshing: boolean;
@@ -21,7 +21,7 @@ export declare class ModelCatalogSyncService {
     constructor(options?: {
         intervalMs?: number;
         onUpdated?: (modelCount: number) => void;
-        xopcCloud?: XopcCloudConnectionService;
+        xopcCloud?: XopcCloudModelSource;
         getConfig?: () => Config;
         catalogStore?: ModelCatalogStore;
         loadProviders?: () => ModelsJsonConfig['providers'];
@@ -32,8 +32,7 @@ export declare class ModelCatalogSyncService {
     start(): void;
     stop(): void;
     getStatus(): ModelCatalogSyncStatus;
-    getXopcCloudConnection(): XopcCloudConnectionService;
-    refreshNow(): Promise<Awaited<ReturnType<XopcCloudConnectionService['refreshCatalog']>>>;
+    refreshNow(): Promise<Awaited<ReturnType<XopcCloudModelSource['refresh']>>>;
     refreshAll(): Promise<{
         updatedSources: string[];
     }>;

package/dist/src/providers/model-catalog-sync-service.js

@@ -4,7 +4,7 @@ import { init_models_json, loadModelsJson } from "../config/models-json.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
 import { getModelRegistry, init_model_registry } from "./model-registry.js";
 import { discoverProviderModels, isProviderApiDiscoverable } from "./model-discovery.js";
-import { XopcCloudConnectionService } from "./xopc-cloud-connection.js";
+import { XopcCloudModelSource } from "./xopc-cloud-model-source.js";
 //#region src/providers/model-catalog-sync-service.ts
 init_logger();
 init_models_json();
@@ -23,11 +23,7 @@ var ModelCatalogSyncService = class {
 	};
 	constructor(options = {}) {
 		this.options = options;
-		this.xopcCloud = options.xopcCloud ?? new XopcCloudConnectionService();
-		try {
-			const lastSuccessAt = getModelCatalogStore().getSource("xopc-cloud")?.lastSuccessAt;
-			if (lastSuccessAt !== void 0) this.status.lastSuccessAt = lastSuccessAt;
-		} catch {}
+		this.xopcCloud = options.xopcCloud ?? new XopcCloudModelSource();
 	}
 	start() {
 		if (this.status.running) return;
@@ -47,21 +43,15 @@ var ModelCatalogSyncService = class {
 	getStatus() {
 		return { ...this.status };
 	}
-	getXopcCloudConnection() {
-		return this.xopcCloud;
-	}
 	refreshNow() {
 		if (this.refreshPromise) return this.refreshPromise;
 		this.status.refreshing = true;
 		this.status.lastAttemptAt = Date.now();
-		this.refreshPromise = this.xopcCloud.refreshCatalog().then((result) => {
+		this.refreshPromise = this.xopcCloud.refresh().then((result) => {
 			if (result.status === "updated") {
 				this.status.lastSuccessAt = Date.now();
 				this.status.lastError = void 0;
 				this.options.onUpdated?.(result.modelCount ?? 0);
-			} else if (result.status === "unchanged") {
-				this.status.lastSuccessAt = Date.now();
-				this.status.lastError = void 0;
 			}
 			return result;
 		}).catch((err) => {

package/dist/src/providers/model-registry.js

@@ -313,7 +313,6 @@ var init_model_registry = __esmMin((() => {
 				const modelOverrides = /* @__PURE__ */ new Map();
 				const apiKeyConfigs = /* @__PURE__ */ new Map();
 				for (const [providerName, providerConfig] of Object.entries(config.providers)) {
-					if (providerName === "xopc-cloud") continue;
 					if (providerConfig.baseUrl || providerConfig.headers || providerConfig.apiKey) overrides.set(providerName, {
 						baseUrl: providerConfig.baseUrl,
 						headers: providerConfig.headers,
@@ -341,7 +340,6 @@ var init_model_registry = __esmMin((() => {
 			const models = [];
 			const defaults = getDefaultModelValues();
 			for (const [providerName, providerConfig] of Object.entries(config.providers)) {
-				if (providerName === "xopc-cloud") continue;
 				const modelDefs = providerConfig.models ?? [];
 				if (modelDefs.length === 0) continue;
 				for (const modelDef of modelDefs) {

package/dist/src/providers/xopc-cloud-model-source.d.ts

@@ -0,0 +1,30 @@
+import { type CredentialResolver } from '../auth/credentials.js';
+import { type ModelCatalogStore } from './model-catalog-store.js';
+export type XopcCloudModelRefreshResult = {
+    status: 'skipped';
+    reason: 'not_configured';
+} | {
+    status: 'updated';
+    modelCount: number;
+    models: string[];
+};
+export declare class XopcCloudModelError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+export declare class XopcCloudModelSource {
+    private readonly fetchImpl;
+    private readonly routerUrl;
+    private readonly credentials;
+    private readonly catalogStore;
+    private readonly refreshModels;
+    constructor(options?: {
+        fetchImpl?: typeof fetch;
+        routerUrl?: string;
+        credentials?: Pick<CredentialResolver, 'resolveApiKey'>;
+        catalogStore?: ModelCatalogStore;
+        refreshModels?: () => void;
+    });
+    refresh(): Promise<XopcCloudModelRefreshResult>;
+}

package/dist/src/providers/xopc-cloud-model-source.js

@@ -0,0 +1,68 @@
+import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
+import { getModelRegistry, init_model_registry } from "./model-registry.js";
+import { getCredentialResolver, init_credentials } from "../auth/credentials.js";
+//#region src/providers/xopc-cloud-model-source.ts
+init_credentials();
+init_model_catalog_store();
+init_model_registry();
+const DEFAULT_ROUTER_URL = "https://router.xopc.ai/v1";
+var XopcCloudModelError = class extends Error {
+	constructor(message, status, code) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.name = "XopcCloudModelError";
+	}
+};
+var XopcCloudModelSource = class {
+	fetchImpl;
+	routerUrl;
+	credentials;
+	catalogStore;
+	refreshModels;
+	constructor(options = {}) {
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.routerUrl = (options.routerUrl ?? process.env.XOPC_MODEL_ROUTER_URL ?? DEFAULT_ROUTER_URL).replace(/\/+$/, "");
+		this.credentials = options.credentials ?? getCredentialResolver();
+		this.catalogStore = options.catalogStore ?? getModelCatalogStore();
+		this.refreshModels = options.refreshModels ?? (() => getModelRegistry().refresh());
+	}
+	async refresh() {
+		const accessToken = await this.credentials.resolveApiKey("xopc-cloud");
+		if (!accessToken) return {
+			status: "skipped",
+			reason: "not_configured"
+		};
+		const response = await this.fetchImpl(`${this.routerUrl}/models`, {
+			headers: {
+				authorization: `Bearer ${accessToken}`,
+				accept: "application/json"
+			},
+			signal: AbortSignal.timeout(3e4)
+		});
+		const body = await response.json().catch(() => null);
+		if (!response.ok) throw new XopcCloudModelError(typeof body?.error?.message === "string" ? body.error.message : `XOPC model discovery failed (${response.status})`, response.status, typeof body?.error?.code === "string" ? body.error.code : void 0);
+		if (!Array.isArray(body?.data)) throw new XopcCloudModelError("XOPC model discovery returned an invalid response", response.status, "invalid_response");
+		const models = [...new Set(body.data.map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0))];
+		this.catalogStore.replaceSourceModels("xopc-cloud", {
+			providerId: "xopc-cloud",
+			baseUrl: this.routerUrl,
+			api: "openai-completions",
+			etag: response.headers.get("x-xopc-model-catalog-version"),
+			recommendedModel: models[0] ?? null,
+			lastSuccessAt: Date.now()
+		}, models.map((id) => ({
+			id,
+			name: id,
+			maxOutputTokens: null
+		})));
+		this.refreshModels();
+		return {
+			status: "updated",
+			modelCount: models.length,
+			models
+		};
+	}
+};
+//#endregion
+export { XopcCloudModelError, XopcCloudModelSource };

package/dist/src/work-discovery/analyzer.js

@@ -7,6 +7,7 @@ init_schema();
 init_providers();
 const MAX_MODEL_CONTEXT_CHARS = 12e4;
 const MAX_PERSONAL_CONTEXT_CHARS = 1e5;
+const WORK_ANALYSIS_MAX_TOKENS = 6e3;
 function extractText(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return "";
@@ -17,16 +18,24 @@ function extractText(content) {
 	}).join("");
 }
 function parseJson(raw) {
-	const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(raw)?.[1];
+	const candidates = [];
+	for (const match of raw.matchAll(/```json\s*([\s\S]*?)```/gi)) if (match[1]) candidates.push(match[1]);
+	candidates.push(raw.trim());
+	for (const match of raw.matchAll(/```(?:[^\n]*)?\s*([\s\S]*?)```/g)) if (match[1]) candidates.push(match[1]);
 	const start = raw.indexOf("{");
 	const end = raw.lastIndexOf("}");
-	const candidate = fenced ?? (start >= 0 && end > start ? raw.slice(start, end + 1) : raw);
-	try {
+	if (start >= 0 && end > start) candidates.push(raw.slice(start, end + 1));
+	for (const candidate of new Set(candidates)) try {
 		const value = JSON.parse(candidate);
-		return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-	} catch {
-		return null;
-	}
+		if (value && typeof value === "object" && !Array.isArray(value)) return value;
+	} catch {}
+	return null;
+}
+function invalidJsonError(label, response, raw) {
+	const outputChars = raw.length;
+	if (response.stopReason === "length") return /* @__PURE__ */ new Error(`${label} response was truncated before completing valid JSON (outputChars=${outputChars})`);
+	if (response.stopReason === "error" && typeof response.errorMessage === "string") return /* @__PURE__ */ new Error(`${label} model request failed: ${response.errorMessage}`);
+	return /* @__PURE__ */ new Error(`${label} did not return valid JSON (stopReason=${String(response.stopReason)}, outputChars=${outputChars})`);
 }
 function strings(value, max) {
 	return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0).slice(0, max).map((item) => item.trim()) : [];
@@ -152,7 +161,7 @@ async function analyzeWorkContext(input) {
 	};
 	const model = resolveModel(modelRef);
 	const compactSnapshot = snapshotForModel(input.snapshot);
-	const parsed = parseJson(extractText((await completeWithResolvedCredentials(model, { messages: [{
+	const response = await completeWithResolvedCredentials(model, { messages: [{
 		role: "user",
 		content: [
 			"You help a user resume real work in one explicitly selected local folder.",
@@ -188,11 +197,13 @@ async function analyzeWorkContext(input) {
 		].join("\n"),
 		timestamp: Date.now()
 	}] }, {
-		maxTokens: 2500,
+		maxTokens: WORK_ANALYSIS_MAX_TOKENS,
 		temperature: .1,
 		signal: input.signal
-	})).content));
-	if (!parsed) throw new Error("Analysis did not return valid JSON");
+	});
+	const raw = extractText(response.content);
+	const parsed = parseJson(raw);
+	if (!parsed) throw invalidJsonError("Analysis", response, raw);
 	if (parsed.lowConfidence === true) return {
 		modelRef,
 		result: lowConfidenceResult(input.snapshot, typeof parsed.contextQuestion === "string" ? parsed.contextQuestion.trim().slice(0, 500) : void 0)
@@ -266,7 +277,7 @@ async function analyzePersonalContext(input) {
 		input.workContext ? `Work-directory understanding from the same one-shot investigation:\n${JSON.stringify(input.workContext)}` : "",
 		JSON.stringify(items)
 	].join("\n");
-	const parsed = parseJson(extractText((await completeWithResolvedCredentials(resolveModel(modelRef), { messages: [{
+	const response = await completeWithResolvedCredentials(resolveModel(modelRef), { messages: [{
 		role: "user",
 		content: prompt,
 		timestamp: Date.now()
@@ -274,8 +285,10 @@ async function analyzePersonalContext(input) {
 		maxTokens: 1500,
 		temperature: .1,
 		signal: input.signal
-	})).content));
-	if (!parsed) throw new Error("Personal context analysis did not return valid JSON");
+	});
+	const raw = extractText(response.content);
+	const parsed = parseJson(raw);
+	if (!parsed) throw invalidJsonError("Personal context analysis", response, raw);
 	const profileCandidates = Array.isArray(parsed.profileCandidates) ? parsed.profileCandidates.map(validateProfileCandidate).filter((value) => Boolean(value)).slice(0, 6) : [];
 	const allowedRefs = new Set(items.map((item) => item.ref));
 	return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xopcai/xopc",
-  "version": "0.0.163",
+  "version": "0.0.164",
   "description": "Local-first AI system that remembers context, coordinates AI, and sustains long-term progress.",
   "type": "module",
   "main": "dist/src/index.js",