@meistrari/chat-nuxt 4.3.0 → 4.4.0-rc.1

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@meistrari/chat-nuxt",
   "configKey": "chatNuxt",
-  "version": "4.3.0-rc.1",
+  "version": "4.4.0-rc.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/types/schemas/chat/chat-config.d.ts

@@ -4,3 +4,9 @@ export declare const AGENT_API_V5_CONFIG_KEY = "agent-api-v5";
 export declare const CONVERSATION_V2_CONFIG_KEY = "conversation-v2";
 export declare const PRE_WAKE_CACHE_CONFIG_KEY = "pre-wake-cache";
 export declare const ROUTE_CLAUDE_VIA_GATEWAY_CONFIG_KEY = "route-claude-via-gateway";
+export type ChatHarness = 'claude' | 'lightweight';
+export type ChatConfig = {
+    harness?: ChatHarness;
+    [key: string]: boolean | ChatHarness | undefined;
+};
+export declare function resolveChatHarness(config?: Pick<ChatConfig, 'harness'>): ChatHarness;

package/dist/runtime/types/schemas/chat/chat-config.js

@@ -4,3 +4,6 @@ export const AGENT_API_V5_CONFIG_KEY = 'agent-api-v5';
 export const CONVERSATION_V2_CONFIG_KEY = 'conversation-v2';
 export const PRE_WAKE_CACHE_CONFIG_KEY = 'pre-wake-cache';
 export const ROUTE_CLAUDE_VIA_GATEWAY_CONFIG_KEY = 'route-claude-via-gateway';
+export function resolveChatHarness(config) {
+    return config?.harness === 'lightweight' ? 'lightweight' : 'claude';
+}

package/dist/runtime/types/schemas/chat/conversation-runtime.d.ts

@@ -23,6 +23,7 @@ export declare const conversationWakeStateSchema: z.ZodEnum<{
     ready: "ready";
     stale: "stale";
     checking: "checking";
+    not_required: "not_required";
 }>;
 export type ConversationWakeState = z.infer<typeof conversationWakeStateSchema>;
 export declare const wakeConversationResponseSchema: z.ZodObject<{
@@ -33,6 +34,7 @@ export declare const wakeConversationResponseSchema: z.ZodObject<{
         ready: "ready";
         stale: "stale";
         checking: "checking";
+        not_required: "not_required";
     }>;
     sessionId: z.ZodNullable<z.ZodString>;
     error: z.ZodNullable<z.ZodString>;

package/dist/runtime/types/schemas/chat/conversation-runtime.js

@@ -15,7 +15,7 @@ export const turnRuntimeStateNameSchema = z.enum([
     'failed',
     'cancelled',
 ]);
-export const conversationWakeStateSchema = z.enum(['stale', 'checking', 'waking', 'ready', 'parked', 'failed']);
+export const conversationWakeStateSchema = z.enum(['stale', 'checking', 'waking', 'ready', 'not_required', 'parked', 'failed']);
 export const wakeConversationResponseSchema = z.object({
     state: conversationWakeStateSchema,
     sessionId: z.string().nullable(),

package/dist/runtime/types/schemas/chat/conversations.d.ts

@@ -260,6 +260,29 @@ export declare const createConversationRequestSchema: z.ZodObject<{
     }, z.core.$strip>], "type">>>;
 }, z.core.$strict>;
 export type CreateConversationRequest = z.infer<typeof createConversationRequestSchema>;
+/** Request contract when x-chat-config selects harness: lightweight. Availability is workspace-scoped. */
+export declare const createLightweightConversationRequestSchema: z.ZodObject<{
+    reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>>;
+    agentInputs: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        name: z.ZodString;
+        vaultRef: z.ZodString;
+        filename: z.ZodString;
+        metadata: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        name: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type CreateLightweightConversationRequest = z.infer<typeof createLightweightConversationRequestSchema>;
 export declare const conversationEventSchema: z.ZodObject<{
     id: z.ZodString;
     conversationId: z.ZodString;
@@ -427,6 +450,19 @@ export declare const updateConversationRequestSchema: z.ZodObject<{
     }>>>;
 }, z.core.$strict>;
 export type UpdateConversationRequest = z.infer<typeof updateConversationRequestSchema>;
+/** Request contract when x-chat-config selects harness: lightweight. Claude keeps its existing model enum. */
+export declare const updateLightweightConversationRequestSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type UpdateLightweightConversationRequest = z.infer<typeof updateLightweightConversationRequestSchema>;
 export declare const moveConversationRequestSchema: z.ZodObject<{
     groupId: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;

package/dist/runtime/types/schemas/chat/conversations.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { telaAgentExecutionInputSchema } from '../integrations/tela-agent-api';
 import { messageFileSchema } from './files';
 import { chatModelSchema, chatReasoningEffortSchema } from './models';
+import { chatModelSchema as lightweightModelSchema } from './lightweight-models';
 import { conversationCreatorFilterSchema, messageRoleSchema, messageStatusSchema, } from './primitives';
 import { resolvedWorkspaceSettingsSchema } from './workspace-settings';
 export const conversationSchema = z.object({
@@ -64,6 +65,10 @@ export const createConversationRequestSchema = z.strictObject({
     reasoningEffort: chatReasoningEffortSchema.nullable().optional(),
     agentInputs: z.array(telaAgentExecutionInputSchema).optional(),
 });
+/** Request contract when x-chat-config selects harness: lightweight. Availability is workspace-scoped. */
+export const createLightweightConversationRequestSchema = createConversationRequestSchema.extend({
+    model: lightweightModelSchema.nullable().optional(),
+});
 export const conversationEventSchema = z.object({
     id: z.string(),
     conversationId: z.string(),
@@ -105,6 +110,10 @@ export const updateConversationRequestSchema = z.strictObject({
     model: chatModelSchema.nullable().optional(),
     reasoningEffort: chatReasoningEffortSchema.nullable().optional(),
 });
+/** Request contract when x-chat-config selects harness: lightweight. Claude keeps its existing model enum. */
+export const updateLightweightConversationRequestSchema = updateConversationRequestSchema.extend({
+    model: lightweightModelSchema.nullable().optional(),
+});
 export const moveConversationRequestSchema = z.object({
     groupId: z.string().nullable(),
 });

package/dist/runtime/types/schemas/chat/lightweight-models.d.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+export declare const chatModelSchema: z.ZodString;
+export type ChatModel = z.infer<typeof chatModelSchema>;
+export declare const chatModelCatalogEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    vendor: z.ZodString;
+    harness: z.ZodEnum<{
+        claude: "claude";
+        lightweight: "lightweight";
+        codex: "codex";
+    }>;
+    provider: z.ZodString;
+    providerOptions: z.ZodArray<z.ZodEnum<{
+        bedrock: "bedrock";
+        vertex: "vertex";
+        anthropic: "anthropic";
+    }>>;
+    contextWindow: z.ZodNumber;
+    maxOutputTokens: z.ZodNullable<z.ZodNumber>;
+    inputModalities: z.ZodArray<z.ZodEnum<{
+        file: "file";
+        text: "text";
+        image: "image";
+        audio: "audio";
+        video: "video";
+    }>>;
+    tier: z.ZodNumber;
+    pricing: z.ZodNullable<z.ZodObject<{
+        promptPerMillion: z.ZodNumber;
+        completionPerMillion: z.ZodNumber;
+        inputCacheReadPerMillion: z.ZodOptional<z.ZodNumber>;
+        inputCacheWritePerMillion: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        available: "available";
+        deprecated: "deprecated";
+    }>;
+    aliasOf: z.ZodNullable<z.ZodString>;
+    isDefault: z.ZodBoolean;
+}, z.core.$strip>;
+export type ChatModelCatalogEntry = z.infer<typeof chatModelCatalogEntrySchema>;
+export declare const chatModelCatalogResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        vendor: z.ZodString;
+        harness: z.ZodEnum<{
+            claude: "claude";
+            lightweight: "lightweight";
+            codex: "codex";
+        }>;
+        provider: z.ZodString;
+        providerOptions: z.ZodArray<z.ZodEnum<{
+            bedrock: "bedrock";
+            vertex: "vertex";
+            anthropic: "anthropic";
+        }>>;
+        contextWindow: z.ZodNumber;
+        maxOutputTokens: z.ZodNullable<z.ZodNumber>;
+        inputModalities: z.ZodArray<z.ZodEnum<{
+            file: "file";
+            text: "text";
+            image: "image";
+            audio: "audio";
+            video: "video";
+        }>>;
+        tier: z.ZodNumber;
+        pricing: z.ZodNullable<z.ZodObject<{
+            promptPerMillion: z.ZodNumber;
+            completionPerMillion: z.ZodNumber;
+            inputCacheReadPerMillion: z.ZodOptional<z.ZodNumber>;
+            inputCacheWritePerMillion: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            available: "available";
+            deprecated: "deprecated";
+        }>;
+        aliasOf: z.ZodNullable<z.ZodString>;
+        isDefault: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const chatModelsResponseSchema: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        vendor: z.ZodString;
+        harness: z.ZodEnum<{
+            claude: "claude";
+            lightweight: "lightweight";
+            codex: "codex";
+        }>;
+        provider: z.ZodString;
+        providerOptions: z.ZodArray<z.ZodEnum<{
+            bedrock: "bedrock";
+            vertex: "vertex";
+            anthropic: "anthropic";
+        }>>;
+        contextWindow: z.ZodNumber;
+        maxOutputTokens: z.ZodNullable<z.ZodNumber>;
+        inputModalities: z.ZodArray<z.ZodEnum<{
+            file: "file";
+            text: "text";
+            image: "image";
+            audio: "audio";
+            video: "video";
+        }>>;
+        tier: z.ZodNumber;
+        pricing: z.ZodNullable<z.ZodObject<{
+            promptPerMillion: z.ZodNumber;
+            completionPerMillion: z.ZodNumber;
+            inputCacheReadPerMillion: z.ZodOptional<z.ZodNumber>;
+            inputCacheWritePerMillion: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            available: "available";
+            deprecated: "deprecated";
+        }>;
+        aliasOf: z.ZodNullable<z.ZodString>;
+        isDefault: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function isValidChatModel(value: unknown): value is ChatModel;
+export { chatReasoningEffortSchema, chatReasoningEffortValues, isValidChatReasoningEffort } from './models';
+export type { ChatReasoningEffort } from './models';

package/dist/runtime/types/schemas/chat/lightweight-models.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export const chatModelSchema = z.string().trim().min(1);
+export const chatModelCatalogEntrySchema = z.object({
+    id: chatModelSchema,
+    name: z.string().min(1),
+    vendor: z.string().min(1),
+    harness: z.enum(['claude', 'codex', 'lightweight']),
+    provider: z.string().min(1),
+    providerOptions: z.array(z.enum(['bedrock', 'vertex', 'anthropic'])),
+    contextWindow: z.number().int().positive(),
+    maxOutputTokens: z.number().int().positive().nullable(),
+    inputModalities: z.array(z.enum(['text', 'image', 'file', 'audio', 'video'])),
+    tier: z.number().int().min(1).max(5),
+    pricing: z.object({
+        promptPerMillion: z.number().nonnegative(),
+        completionPerMillion: z.number().nonnegative(),
+        inputCacheReadPerMillion: z.number().nonnegative().optional(),
+        inputCacheWritePerMillion: z.number().nonnegative().optional(),
+    }).nullable(),
+    status: z.enum(['available', 'deprecated']),
+    aliasOf: chatModelSchema.nullable(),
+    isDefault: z.boolean(),
+});
+export const chatModelCatalogResponseSchema = z.object({
+    success: z.literal(true),
+    models: z.array(chatModelCatalogEntrySchema),
+});
+export const chatModelsResponseSchema = z.object({
+    models: z.array(chatModelCatalogEntrySchema),
+});
+export function isValidChatModel(value) {
+    return chatModelSchema.safeParse(value).success;
+}
+export { chatReasoningEffortSchema, chatReasoningEffortValues, isValidChatReasoningEffort } from './models';

package/dist/runtime/types/schemas/index.d.ts

@@ -5,6 +5,8 @@ export * from './chat/credentials';
 export * from './chat/external-skills';
 export * from './chat/files';
 export * from './chat/github';
+export { chatModelCatalogEntrySchema, chatModelCatalogResponseSchema, chatModelsResponseSchema, isValidChatModel as isValidLightweightChatModel, chatModelSchema as lightweightChatModelSchema, } from './chat/lightweight-models';
+export type { ChatModelCatalogEntry, ChatModel as LightweightChatModel } from './chat/lightweight-models';
 export * from './chat/messages';
 export * from './chat/models';
 export * from './chat/primitives';
@@ -14,6 +16,7 @@ export * from './chat/usage';
 export * from './chat/workspace-agent';
 export * from './chat/workspace-settings';
 export * from './integrations/agent-api';
+export * from './integrations/lightweight';
 export * from './integrations/tela-agent-api';
 export * from './integrations/tela-api';
 export * from './tools/canvas';

package/dist/runtime/types/schemas/index.js

@@ -5,6 +5,7 @@ export * from './chat/credentials';
 export * from './chat/external-skills';
 export * from './chat/files';
 export * from './chat/github';
+export { chatModelCatalogEntrySchema, chatModelCatalogResponseSchema, chatModelsResponseSchema, isValidChatModel as isValidLightweightChatModel, chatModelSchema as lightweightChatModelSchema, } from './chat/lightweight-models';
 export * from './chat/messages';
 export * from './chat/models';
 export * from './chat/primitives';
@@ -14,6 +15,7 @@ export * from './chat/usage';
 export * from './chat/workspace-agent';
 export * from './chat/workspace-settings';
 export * from './integrations/agent-api';
+export * from './integrations/lightweight';
 export * from './integrations/tela-agent-api';
 export * from './integrations/tela-api';
 export * from './tools/canvas';

package/dist/runtime/types/schemas/integrations/lightweight.d.ts

@@ -0,0 +1,17 @@
+import type { MessageFile } from '../chat/files';
+import type { ReasoningItem } from './agent-api';
+export declare function lightweightFiles(value: unknown): MessageFile[];
+export declare function createLightweightTurn(runId: string, sessionId: string): {
+    runId: string;
+    sessionId: string;
+    lastSequence: number;
+    text: string;
+    pendingText: string;
+    thinking: string;
+    reasoning: ReasoningItem[];
+    toolFiles: MessageFile[];
+    files: MessageFile[];
+};
+export type LightweightTurn = ReturnType<typeof createLightweightTurn>;
+export declare function applyLightweightPart(state: LightweightTurn, part: Record<string, unknown>, sequence: number, timestamp: number): boolean;
+export declare function lightweightThreadReasoning(sessionId: string, runId: string, events: Record<string, unknown>[]): ReasoningItem[];

package/dist/runtime/types/schemas/integrations/lightweight.js

@@ -0,0 +1,135 @@
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function stringify(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value) ?? '';
+}
+function argumentsOf(value) {
+    if (isRecord(value))
+        return value;
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            if (isRecord(parsed))
+                return parsed;
+        }
+        catch { }
+    }
+    return { value };
+}
+function reasoningItem(sessionId, uuid, content, timestamp, role = 'assistant') {
+    return { type: role, uuid, message: { role, content: [content] }, timestamp, session_id: sessionId, timeElapsed: 0, parent_tool_use_id: null };
+}
+export function lightweightFiles(value) {
+    const files = new Map();
+    function visit(candidate, name) {
+        if (Array.isArray(candidate)) {
+            for (const item of candidate)
+                visit(item, name);
+        }
+        else if (isRecord(candidate)) {
+            const fileName = candidate.fileName ?? candidate.filename ?? candidate.name;
+            for (const item of Object.values(candidate))
+                visit(item, typeof fileName === 'string' ? fileName : name);
+        }
+        else if (typeof candidate === 'string') {
+            try {
+                const parsed = JSON.parse(candidate);
+                if (typeof parsed !== 'string') {
+                    visit(parsed, name);
+                    return;
+                }
+            }
+            catch { }
+            for (const match of candidate.matchAll(/vault:\/\/[^\s"'`<>)}\]]+/g)) {
+                const url = match[0].replace(/[.,;:!?]+$/, '');
+                const existing = files.get(url);
+                files.set(url, { url, name: name ?? existing?.name ?? url.split('/').at(-1) ?? 'attachment', source: 'assistant' });
+            }
+        }
+    }
+    visit(value);
+    return [...files.values()];
+}
+export function createLightweightTurn(runId, sessionId) {
+    return {
+        runId,
+        sessionId,
+        lastSequence: -1,
+        text: '',
+        pendingText: '',
+        thinking: '',
+        reasoning: [],
+        toolFiles: [],
+        files: [],
+    };
+}
+function upsertReasoning(state, item) {
+    const index = state.reasoning.findIndex(existing => existing.uuid === item.uuid);
+    if (index < 0)
+        state.reasoning.push(item);
+    else
+        state.reasoning[index] = item;
+}
+export function applyLightweightPart(state, part, sequence, timestamp) {
+    if (sequence <= state.lastSequence)
+        return false;
+    state.lastSequence = sequence;
+    const delta = typeof part.delta === 'string' ? part.delta : typeof part.text === 'string' ? part.text : '';
+    if (part.type === 'text-delta') {
+        state.text += delta;
+        state.pendingText += delta;
+        state.files = lightweightFiles([state.toolFiles, state.text]);
+        return true;
+    }
+    if (part.type === 'reasoning-delta') {
+        state.thinking += delta;
+        const id = `${state.runId}:thinking:${typeof part.id === 'string' ? part.id : 'default'}`;
+        const existing = state.reasoning.find(item => item.uuid === id)?.message.content[0];
+        const text = existing && 'text' in existing && typeof existing.text === 'string' ? existing.text : '';
+        upsertReasoning(state, reasoningItem(state.sessionId, id, { type: 'text', text: text + delta }, timestamp));
+        return true;
+    }
+    if (part.type === 'tool-call' && typeof part.toolCallId === 'string') {
+        if (state.pendingText) {
+            upsertReasoning(state, reasoningItem(state.sessionId, `${state.runId}:text:${sequence}`, { type: 'text', text: state.pendingText }, timestamp));
+            state.pendingText = '';
+        }
+        upsertReasoning(state, reasoningItem(state.sessionId, `${state.runId}:call:${part.toolCallId}`, {
+            type: 'tool_use',
+            id: part.toolCallId,
+            name: typeof part.toolName === 'string' ? part.toolName : 'Tool',
+            input: argumentsOf(part.input),
+        }, timestamp));
+        return true;
+    }
+    if ((part.type === 'tool-result' || part.type === 'tool-error') && typeof part.toolCallId === 'string') {
+        const output = part.type === 'tool-error' ? part.error : part.output;
+        upsertReasoning(state, reasoningItem(state.sessionId, `${state.runId}:result:${part.toolCallId}`, {
+            type: 'tool_result',
+            tool_use_id: part.toolCallId,
+            content: stringify(output),
+            is_error: part.type === 'tool-error',
+        }, timestamp, 'user'));
+        state.toolFiles = lightweightFiles([state.toolFiles, output]);
+        state.files = lightweightFiles([state.toolFiles, state.text]);
+        return true;
+    }
+    return false;
+}
+export function lightweightThreadReasoning(sessionId, runId, events) {
+    const state = createLightweightTurn(runId, sessionId);
+    for (const [index, event] of events.entries()) {
+        const timestamp = typeof event.timestamp === 'number' ? event.timestamp : 0;
+        if ((event.type === 'thinking' || event.type === 'text') && typeof event.text === 'string') {
+            upsertReasoning(state, reasoningItem(sessionId, `${runId}:${event.type}:${event.sequenceIndex ?? index}`, { type: 'text', text: event.text }, timestamp));
+        }
+        else if (event.type === 'tool_call') {
+            applyLightweightPart(state, { type: 'tool-call', toolCallId: event.callId, toolName: event.toolName, input: event.arguments }, index, timestamp);
+        }
+        else if (event.type === 'tool_result' && isRecord(event.result)) {
+            applyLightweightPart(state, { type: event.result.isError ? 'tool-error' : 'tool-result', toolCallId: event.callId, output: event.result.output, error: event.result.output }, index, timestamp);
+        }
+    }
+    return state.reasoning;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/chat-nuxt",
-  "version": "4.3.0",
+  "version": "4.4.0-rc.1",
   "type": "module",
   "exports": {
     ".": {