@schlenkr/ragents 0.1.10 → 0.1.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schlenkr/ragents",
-  "version": "0.1.10",
-  "description": "RAgents-Host: Server, Engine, Plugins und Werkzeuge ohne Quell-Checkout",
+  "version": "0.1.12",
+  "description": "RAgents host: server, engine, plugins and tools without a source checkout",
   "keywords": [
     "agents",
     "llm",
@@ -55,7 +55,7 @@
     "lucide-react": "1.46.0",
     "partial-json": "0.1.7",
     "playwright-core": "1.61.1",
-    "quassel": "0.3.0",
+    "quassel": "0.4.0",
     "react": "19.2.8",
     "react-diff-view": "3.3.3",
     "react-dom": "19.2.8",
@@ -70,6 +70,6 @@
     "yaml": "2.9.0"
   },
   "ragents": {
-    "hostVersion": "e537e04d1de43970476a58776b21c5c5715d83aa"
+    "hostVersion": "55809ced98ff0942000fe35814f61ad5343b2337"
   }
 }

package/packages/agent/dist/core/model-runtime.d.ts

@@ -1,4 +1,4 @@
-import { type Api, type AssistantMessage, type AssistantMessageEventStream, type AuthCheck, type AuthResult, type Context, type Model, type ModelCompaction, type SimpleStreamOptions } from "@ragents/ai";
+import { type Api, type AssistantMessage, type AssistantMessageEventStream, type AuthCheck, type AuthResult, type Context, type Model, type ModelCompaction, type ModelThinkingLevel, type SimpleStreamOptions } from "@ragents/ai";
 import { type ProviderConfigInput } from "./provider-composer.ts";
 /** A name under which a model of another provider is offered, with its own compaction values; only the alias is visible to callers. */
 export interface ModelAlias {
@@ -6,8 +6,12 @@ export interface ModelAlias {
     readonly upstream: string;
     readonly model: string;
     readonly compaction: ModelCompaction;
+    /** The levels the alias offers, each mapped to a level of the target; without it the alias offers the target's levels. */
+    readonly thinkingLevels?: Readonly<Partial<Record<ModelThinkingLevel, ModelThinkingLevel>>>;
 }
-/** The metadata of the target under the alias as id and name, with the alias provider as provider and the alias's compaction values. */
+/** Why an alias cannot offer these thinking levels, checked against the target if given; without levels it offers the target's. */
+export declare function thinkingLevelsProblem(value: unknown, target?: Model<Api>): string | undefined;
+/** The metadata of the target under the alias as id and name, with the alias provider as provider, the alias's compaction values and the levels it offers. */
 export declare function aliasedModel(providerId: string, entry: ModelAlias, target: Model<Api>): Model<Api>;
 /** The built-in providers plus the ones registered at runtime; a key comes from the registration or the environment. */
 export declare class ModelRuntime {
@@ -28,6 +32,7 @@ export declare class ModelRuntime {
     /** Offers models of registered providers under alias names; requests go to the target, answers carry the alias. */
     registerAliases(providerId: string, aliases: readonly ModelAlias[]): void;
     private aliasModels;
+    /** The target of an alias with the levels the alias offers, so a request clamps to them and sends the mapped level. */
     private targetOf;
 }
 //# sourceMappingURL=model-runtime.d.ts.map

package/packages/agent/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { aliasedModel, type ModelAlias, ModelRuntime } from "./core/model-runtime.ts";
+export { aliasedModel, type ModelAlias, ModelRuntime, thinkingLevelsProblem } from "./core/model-runtime.ts";
 export { type AgentSettings, type AgentSettingsInput, agentSettings } from "./core/agent-settings.ts";
 export { activeContextEntries, type ContextCompaction, type ContextLogEntry, contextMessages, latestCompaction, } from "./core/context-log.ts";
 export { calculateContextTokens, compact, compactionOf, compactionProblem, type CompactionSource, estimateContextTokens, prepareCompaction, shouldCompact, } from "./core/compaction/index.ts";

package/packages/agent/dist/loop/agent-loop.d.ts

@@ -5,9 +5,9 @@
 import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.ts";
 export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
 /** User message that follows a stop without text and without tool call, typically reasoning-only output. */
-export declare const EMPTY_RESPONSE_NUDGE = "Deine Antwort enthielt weder Text noch Werkzeugaufruf. Antworte jetzt mit dem n\u00E4chsten Werkzeugaufruf oder Deiner Antwort.";
+export declare const EMPTY_RESPONSE_NUDGE = "Your answer contained neither text nor a tool call. Answer now with the next tool call or your answer.";
 /** Error message of the assistant message that ends the loop after the nudge stayed unanswered. */
-export declare const EMPTY_RESPONSE_FAILURE = "Modell lieferte zweimal eine leere Antwort.";
+export declare const EMPTY_RESPONSE_FAILURE = "The model returned an empty response twice.";
 export declare function runAgentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn): Promise<AgentMessage[]>;
 export declare function runAgentLoopContinue(context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal?: AbortSignal, streamFn?: StreamFn): Promise<AgentMessage[]>;
 //# sourceMappingURL=agent-loop.d.ts.map

package/packages/agent/src/core/compaction/utils.ts

@@ -115,7 +115,7 @@ export function serializeConversation(messages: Message[]): string {
 				typeof msg.content === "string"
 					? msg.content
 					: msg.content
-							.map((c) => c.type === "text" ? c.text : `\n[${c.type}: ${c.type === "file" ? `${c.filename}, ` : ""}${c.mimeType}; Originalinhalt beigefügt]\n`)
+							.map((c) => c.type === "text" ? c.text : `\n[${c.type}: ${c.type === "file" ? `${c.filename}, ` : ""}${c.mimeType}; original content attached]\n`)
 							.join("");
 			if (content) parts.push(`[User]: ${content}`);
 		} else if (msg.role === "assistant") {

package/packages/agent/src/core/model-runtime.ts

@@ -7,9 +7,12 @@ import {
 	type AuthResult,
 	type Context,
 	createModels,
+	EXTENDED_THINKING_LEVELS,
+	getSupportedThinkingLevels,
 	lazyStream,
 	type Model,
 	type ModelCompaction,
+	type ModelThinkingLevel,
 	type MutableModels,
 	type Provider,
 	type SimpleStreamOptions,
@@ -24,6 +27,8 @@ export interface ModelAlias {
 	readonly upstream: string;
 	readonly model: string;
 	readonly compaction: ModelCompaction;
+	/** The levels the alias offers, each mapped to a level of the target; without it the alias offers the target's levels. */
+	readonly thinkingLevels?: Readonly<Partial<Record<ModelThinkingLevel, ModelThinkingLevel>>>;
 }
 
 interface AliasRegistration {
@@ -31,9 +36,42 @@ interface AliasRegistration {
 	readonly aliases: ReadonlyMap<string, ModelAlias>;
 }
 
-/** The metadata of the target under the alias as id and name, with the alias provider as provider and the alias's compaction values. */
+/** Why an alias cannot offer these thinking levels, checked against the target if given; without levels it offers the target's. */
+export function thinkingLevelsProblem(value: unknown, target?: Model<Api>): string | undefined {
+	if (value === undefined) return undefined;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return "thinkingLevels needs an object from offered to target level";
+	const levels = Object.entries(value);
+	if (levels.length === 0) return "thinkingLevels needs at least one level";
+	const unknown = levels.find(([offered]) => !EXTENDED_THINKING_LEVELS.includes(offered as ModelThinkingLevel));
+	if (unknown) return `thinkingLevels.${unknown[0]} is not a thinking level`;
+	const invalid = levels.find(([, mapped]) => !EXTENDED_THINKING_LEVELS.includes(mapped as ModelThinkingLevel));
+	if (invalid) return `thinkingLevels.${invalid[0]} names the unknown thinking level "${String(invalid[1])}"`;
+	const off = levels.find(([offered, mapped]) => offered !== "off" && mapped === "off");
+	if (off) return `thinkingLevels.${off[0]} maps to off, which only off may do`;
+	if (!target) return undefined;
+	const supported = getSupportedThinkingLevels(target);
+	const unsupported = levels.find(([, mapped]) => !supported.includes(mapped as ModelThinkingLevel));
+	return unsupported && `thinkingLevels.${unsupported[0]} maps to ${String(unsupported[1])}, which the target does not offer (valid: ${supported.join(", ")})`;
+}
+
+/** The target with only the levels the alias offers, each carrying what the target sends for the level it maps to. */
+function withOfferedThinking(entry: ModelAlias, target: Model<Api>): Model<Api> {
+	const levels = entry.thinkingLevels;
+	if (!levels) return target;
+	return {
+		...target,
+		thinkingLevelMap: Object.fromEntries(EXTENDED_THINKING_LEVELS.flatMap((level): [ModelThinkingLevel, string | null][] => {
+			const mapped = levels[level];
+			if (mapped === undefined) return [[level, null]];
+			const sent = mapped === "off" ? target.thinkingLevelMap?.off : (target.thinkingLevelMap?.[mapped] ?? mapped);
+			return sent === undefined ? [] : [[level, sent]];
+		})),
+	};
+}
+
+/** The metadata of the target under the alias as id and name, with the alias provider as provider, the alias's compaction values and the levels it offers. */
 export function aliasedModel(providerId: string, entry: ModelAlias, target: Model<Api>): Model<Api> {
-	return { ...target, id: entry.alias, name: entry.alias, provider: providerId, compaction: entry.compaction };
+	return { ...withOfferedThinking(entry, target), id: entry.alias, name: entry.alias, provider: providerId, compaction: entry.compaction };
 }
 
 /** The built-in providers plus the ones registered at runtime; a key comes from the registration or the environment. */
@@ -106,7 +144,8 @@ export class ModelRuntime {
 		const missing = aliases.find((entry) => !this.models.getModel(entry.upstream, entry.model));
 		if (missing) throw new Error(`Alias ${missing.alias}: model ${missing.upstream}/${missing.model} is not configured.`);
 		for (const entry of aliases) {
-			const problem = compactionProblem(entry.compaction, this.models.getModel(entry.upstream, entry.model));
+			const target = this.models.getModel(entry.upstream, entry.model);
+			const problem = compactionProblem(entry.compaction, target) ?? thinkingLevelsProblem(entry.thinkingLevels, target);
 			if (problem) throw new Error(`Alias ${entry.alias}: ${problem}.`);
 		}
 		this.aliasRegistration = { provider: providerId, aliases: new Map(aliases.map((entry) => [entry.alias, entry])) };
@@ -121,13 +160,14 @@ export class ModelRuntime {
 		});
 	}
 
+	/** The target of an alias with the levels the alias offers, so a request clamps to them and sends the mapped level. */
 	private targetOf(model: Model<Api>): Model<Api> | undefined {
 		const registration = this.aliasRegistration;
 		if (model.provider !== registration?.provider) return undefined;
 		const entry = registration.aliases.get(model.id);
 		const target = entry && this.models.getModel(entry.upstream, entry.model);
-		if (!target) throw new Error(`Model ${model.provider}/${model.id} is not configured.`);
-		return target;
+		if (!entry || !target) throw new Error(`Model ${model.provider}/${model.id} is not configured.`);
+		return withOfferedThinking(entry, target);
 	}
 }
 

package/packages/agent/src/index.ts

@@ -1,5 +1,5 @@
 // Everything the engine, the server and the workspace executor use; the rest is internal.
-export { aliasedModel, type ModelAlias, ModelRuntime } from "./core/model-runtime.ts";
+export { aliasedModel, type ModelAlias, ModelRuntime, thinkingLevelsProblem } from "./core/model-runtime.ts";
 export { type AgentSettings, type AgentSettingsInput, agentSettings } from "./core/agent-settings.ts";
 export {
 	activeContextEntries,

package/packages/agent/src/loop/agent-loop.ts

@@ -25,10 +25,10 @@ export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
 
 /** User message that follows a stop without text and without tool call, typically reasoning-only output. */
 export const EMPTY_RESPONSE_NUDGE =
-	"Deine Antwort enthielt weder Text noch Werkzeugaufruf. Antworte jetzt mit dem nächsten Werkzeugaufruf oder Deiner Antwort.";
+	"Your answer contained neither text nor a tool call. Answer now with the next tool call or your answer.";
 
 /** Error message of the assistant message that ends the loop after the nudge stayed unanswered. */
-export const EMPTY_RESPONSE_FAILURE = "Modell lieferte zweimal eine leere Antwort.";
+export const EMPTY_RESPONSE_FAILURE = "The model returned an empty response twice.";
 
 function isEmptyResponse(message: AssistantMessage): boolean {
 	return (

package/packages/ai/dist/models.d.ts

@@ -66,6 +66,7 @@ export interface CreateProviderOptions<TApi extends Api = Api> {
  */
 export declare function createProvider<TApi extends Api = Api>(input: CreateProviderOptions<TApi>): Provider<TApi>;
 export declare function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"];
+export declare const EXTENDED_THINKING_LEVELS: readonly ModelThinkingLevel[];
 export declare function getSupportedThinkingLevels<TApi extends Api>(model: Model<TApi>): ModelThinkingLevel[];
 export declare function clampThinkingLevel<TApi extends Api>(model: Model<TApi>, level: ModelThinkingLevel): ModelThinkingLevel;
 //# sourceMappingURL=models.d.ts.map