@nghyane/arcane 0.1.7 → 0.1.10

package/src/sdk.ts

@@ -72,6 +72,7 @@ import {
 	loadSshTool,
 	PythonTool,
 	ReadTool,
+	type SubagentContext,
 	setPreferredImageProvider,
 	setPreferredSearchProvider,
 	type Tool,
@@ -157,12 +158,8 @@ export interface CreateAgentSessionOptions {
 	/** Tool names explicitly requested (enables disabled-by-default tools) */
 	toolNames?: string[];
 
-	/** Output schema for structured completion (subagents) */
-	outputSchema?: unknown;
-	/** Whether to include the submit_result tool by default */
-	requireSubmitResultTool?: boolean;
-	/** Task recursion depth (for subagent sessions). Default: 0 */
-	taskDepth?: number;
+	/** Whether this is a subagent session. Default: false */
+	isSubagent?: boolean;
 	/** Parent task ID prefix for nested artifact naming (e.g., "6-Extensions") */
 	parentTaskPrefix?: string;
 
@@ -223,6 +220,7 @@ export {
 	PythonTool,
 	ReadTool,
 	WriteTool,
+	type SubagentContext,
 	type ToolSession,
 };
 
@@ -629,8 +627,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// For subagent sessions using GitHub Copilot, add X-Initiator header
 	// to ensure proper billing (agent-initiated vs user-initiated)
-	const taskDepth = options.taskDepth ?? 0;
-	const forceCopilotAgentInitiator = taskDepth > 0;
+	const isSubagent = options.isSubagent ?? false;
+	const forceCopilotAgentInitiator = isSubagent;
 	if (forceCopilotAgentInitiator && model?.provider === "github-copilot") {
 		model = {
 			...model,
@@ -722,9 +720,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		contextFiles,
 		skills,
 		eventBus,
-		outputSchema: options.outputSchema,
-		requireSubmitResultTool: options.requireSubmitResultTool,
-		taskDepth: options.taskDepth ?? 0,
+		isSubagent: options.isSubagent ?? false,
 		getSessionFile: () => sessionManager.getSessionFile() ?? null,
 		getSessionId: () => sessionManager.getSessionId?.() ?? null,
 		getSessionSpawns: () => options.spawns ?? "*",
@@ -736,10 +732,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			if (model) return formatModelString(model);
 			return undefined;
 		},
-		getCompactContext: () => session.formatCompactContext(),
+		subagentContext: {
+			getCompactContext: () => session.formatCompactContext(),
+			authStorage,
+			modelRegistry,
+		},
 		settings,
-		authStorage,
-		modelRegistry,
 	};
 
 	// Initialize internal URL router for internal protocols (agent://, artifact://, memory://, skill://, rule://)
@@ -798,7 +796,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		});
 		time("discoverAndLoadMCPTools");
 		mcpManager = mcpResult.manager;
-		toolSession.mcpManager = mcpManager;
+		if (!toolSession.subagentContext) toolSession.subagentContext = {};
+		toolSession.subagentContext.mcpManager = mcpManager;
 
 		// If we extracted Exa API keys from MCP configs and EXA_AARCANE_KEY isn't set, use the first one
 		if (mcpResult.exaApiKeys.length > 0 && !$env.EXA_AARCANE_KEY) {
@@ -1273,7 +1272,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		settings,
 		modelRegistry,
 		agentDir,
-		taskDepth,
+		isSubagent,
 	});
 
 	return {

package/src/session/session-manager.ts

@@ -124,8 +124,6 @@ export interface SessionInitEntry extends SessionEntryBase {
 	task: string;
 	/** Tools available to the agent */
 	tools: string[];
-	/** Output schema if structured output was requested */
-	outputSchema?: unknown;
 }
 
 /** Mode change entry - tracks agent mode transitions. */
@@ -1685,7 +1683,7 @@ export class SessionManager {
 	}
 
 	/** Append session init metadata (for subagent debugging/replay). Returns entry id. */
-	appendSessionInit(init: { systemPrompt: string; task: string; tools: string[]; outputSchema?: unknown }): string {
+	appendSessionInit(init: { systemPrompt: string; task: string; tools: string[] }): string {
 		const entry: SessionInitEntry = {
 			type: "session_init",
 			id: generateId(this.#byId),

package/src/task/executor.ts

@@ -107,7 +107,7 @@ export interface ExecutorOptions {
 	id: string;
 	modelOverride?: string | string[];
 	thinkingLevel?: ThinkingLevel;
-	taskDepth?: number;
+	isSubagent?: boolean;
 	enableLsp?: boolean;
 	signal?: AbortSignal;
 	onProgress?: (progress: AgentProgress) => void;
@@ -682,7 +682,7 @@ export async function runAgent(options: ExecutorOptions): Promise<SingleResult>
 				sessionManager,
 				hasUI: false,
 				spawns: "",
-				taskDepth: (options.taskDepth ?? 0) + 1,
+				isSubagent: true,
 				parentTaskPrefix: id,
 				enableLsp: lspEnabled,
 				skipPythonPreflight,

package/src/task/index.ts

@@ -93,7 +93,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 
 		try {
 			await fs.mkdir(effectiveArtifactsDir, { recursive: true });
-			const compactContext = this.session.getCompactContext?.();
+			const compactContext = this.session.subagentContext?.getCompactContext?.();
 			let contextFilePath: string | undefined;
 			if (compactContext) {
 				contextFilePath = path.join(effectiveArtifactsDir, "context.md");
@@ -164,7 +164,7 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 				description: rendered.description,
 				index: 0,
 				id: uniqueId,
-				taskDepth: this.session.taskDepth ?? 0,
+				isSubagent: true,
 				modelOverride,
 				sessionFile,
 				persistArtifacts: !!artifactsDir,
@@ -177,10 +177,10 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 					progressMap.set(0, { ...structuredClone(progress) });
 					emitProgress();
 				},
-				authStorage: this.session.authStorage,
-				modelRegistry: this.session.modelRegistry,
+				authStorage: this.session.subagentContext?.authStorage,
+				modelRegistry: this.session.subagentContext?.modelRegistry,
 				settings: this.session.settings,
-				mcpManager: this.session.mcpManager,
+				mcpManager: this.session.subagentContext?.mcpManager,
 				contextFiles,
 				skills: resolvedSkills,
 				preloadedSkills,

package/src/task/types.ts

@@ -24,26 +24,13 @@ export const TASK_SUBAGENT_EVENT_CHANNEL = "task:subagent:event";
 /** EventBus channel for aggregated subagent progress */
 export const TASK_SUBAGENT_PROGRESS_CHANNEL = "task:subagent:progress";
 
-/** Single task item for parallel execution */
-export const taskItemSchema = Type.Object({
-	id: Type.String({
-		description: "CamelCase identifier, max 32 chars",
-		maxLength: 32,
-	}),
-	description: Type.String({
-		description: "Short one-liner for UI display only — not seen by the subagent",
-	}),
-	assignment: Type.String({
-		description:
-			"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure. Only include per-task deltas — shared background belongs in `context`.",
-	}),
-	skills: Type.Optional(
-		Type.Array(Type.String(), {
-			description: "Skill names to preload into the subagent. Use only where it changes correctness.",
-		}),
-	),
-});
-export type TaskItem = Static<typeof taskItemSchema>;
+/** Single task item for execution */
+export interface TaskItem {
+	id: string;
+	description: string;
+	assignment: string;
+	skills?: string[];
+}
 
 /** Task schema — single task with optional context */
 export const taskSchema = Type.Object({

package/src/tools/index.ts

@@ -31,7 +31,6 @@ import { PythonTool } from "./python";
 import { ReadTool } from "./read";
 import { ReviewerTool } from "./reviewer-tool";
 import { loadSshTool } from "./ssh";
-import { SubmitResultTool } from "./submit-result";
 import { TodoWriteTool } from "./todo-write";
 import { UndoEditTool } from "./undo-edit";
 import { WriteTool } from "./write";
@@ -94,7 +93,6 @@ export { OracleTool } from "./oracle";
 export { PythonTool, type PythonToolDetails, type PythonToolOptions } from "./python";
 export { ReadTool, type ReadToolDetails, type ReadToolInput } from "./read";
 export { loadSshTool, type SSHToolDetails, SshTool } from "./ssh";
-export { SubmitResultTool } from "./submit-result";
 export { type TodoItem, TodoWriteTool, type TodoWriteToolDetails } from "./todo-write";
 export { UndoEditTool, type UndoEditToolDetails } from "./undo-edit";
 export { WriteTool, type WriteToolDetails, type WriteToolInput } from "./write";
@@ -108,6 +106,14 @@ export type ContextFileEntry = {
 	depth?: number;
 };
 
+/** Forwarded context for spawning subagent processes */
+export interface SubagentContext {
+	authStorage?: import("../session/auth-storage").AuthStorage;
+	modelRegistry?: import("../config/model-registry").ModelRegistry;
+	mcpManager?: import("../mcp/manager").MCPManager;
+	getCompactContext?: () => string;
+}
+
 /** Session context for tool factories */
 export interface ToolSession {
 	/** Current working directory */
@@ -128,12 +134,8 @@ export interface ToolSession {
 	hasEditTool?: boolean;
 	/** Event bus for tool/extension communication */
 	eventBus?: EventBus;
-	/** Output schema for structured completion (subagents) */
-	outputSchema?: unknown;
-	/** Whether to include the submit_result tool by default */
-	requireSubmitResultTool?: boolean;
-	/** Task recursion depth (0 = top-level, 1 = first child, etc.) */
-	taskDepth?: number;
+	/** Whether this session is a subagent (spawned by task tool) */
+	isSubagent?: boolean;
 	/** Get session file */
 	getSessionFile: () => string | null;
 	/** Get session ID */
@@ -148,20 +150,14 @@ export interface ToolSession {
 	getModelString?: () => string | undefined;
 	/** Get the current session model string, regardless of how it was chosen */
 	getActiveModelString?: () => string | undefined;
-	/** Auth storage for passing to subagents (avoids re-discovery) */
-	authStorage?: import("../session/auth-storage").AuthStorage;
-	/** Model registry for passing to subagents (avoids re-discovery) */
-	modelRegistry?: import("../config/model-registry").ModelRegistry;
-	/** MCP manager for proxying MCP calls through parent */
-	mcpManager?: import("../mcp/manager").MCPManager;
+	/** Context for spawning subagent processes (only used by task/subagent tools) */
+	subagentContext?: SubagentContext;
 	/** Internal URL router for agent:// and skill:// URLs */
 	internalRouter?: InternalUrlRouter;
 	/** Agent output manager for unique agent:// IDs across task invocations */
 	agentOutputManager?: AgentOutputManager;
 	/** Settings instance for passing to subagents */
 	settings: Settings;
-	/** Get compact conversation context for subagents (excludes tool results, system prompts) */
-	getCompactContext?: () => string;
 }
 
 type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
@@ -191,10 +187,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	write: s => new WriteTool(s),
 };
 
-export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
-	submit_result: s => new SubmitResultTool(s),
-};
-
 export type ToolName = keyof typeof BUILTIN_TOOLS;
 
 export type PythonToolMode = "ipy-only" | "bash-only" | "both";
@@ -232,7 +224,6 @@ function getPythonModeFromEnv(): PythonToolMode | null {
  */
 export async function createTools(session: ToolSession, toolNames?: string[]): Promise<Tool[]> {
 	time("createTools:start");
-	const includeSubmitResult = session.requireSubmitResultTool === true;
 	const enableLsp = session.enableLsp ?? true;
 	const requestedTools = toolNames && toolNames.length > 0 ? [...new Set(toolNames)] : undefined;
 	const pythonMode = getPythonModeFromEnv() ?? session.settings.get("python.toolMode");
@@ -278,12 +269,12 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	) {
 		requestedTools.push("bash");
 	}
-	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS, ...HIDDEN_TOOLS };
+	const allTools: Record<string, ToolFactory> = { ...BUILTIN_TOOLS };
 	const isToolAllowed = (name: string) => {
 		if (name === "lsp") return enableLsp;
 		if (name === "bash") return allowBash;
 		if (name === "python") return allowPython;
-		if (name === "todo_write") return !includeSubmitResult && session.settings.get("todo.enabled");
+		if (name === "todo_write") return session.settings.get("todo.enabled");
 		if (name === "find") return session.settings.get("find.enabled");
 		if (name === "grep") return session.settings.get("grep.enabled");
 		if (name === "notebook") return session.settings.get("notebook.enabled");
@@ -295,25 +286,17 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "librarian") return session.settings.get("librarian.enabled");
 		if (name === "oracle") return session.settings.get("oracle.enabled");
 		if (name === "task") {
-			const maxDepth = session.settings.get("task.maxRecursionDepth") ?? 2;
-			const currentDepth = session.taskDepth ?? 0;
-			return maxDepth < 0 || currentDepth < maxDepth;
+			return !session.isSubagent;
 		}
 		return true;
 	};
-	if (includeSubmitResult && requestedTools && !requestedTools.includes("submit_result")) {
-		requestedTools.push("submit_result");
-	}
 
 	const filteredRequestedTools = requestedTools?.filter(name => name in allTools && isToolAllowed(name));
 
 	const entries =
 		filteredRequestedTools !== undefined
 			? filteredRequestedTools.map(name => [name, allTools[name]] as const)
-			: [
-					...Object.entries(BUILTIN_TOOLS).filter(([name]) => isToolAllowed(name)),
-					...(includeSubmitResult ? ([["submit_result", HIDDEN_TOOLS.submit_result]] as const) : []),
-				];
+			: [...Object.entries(BUILTIN_TOOLS).filter(([name]) => isToolAllowed(name))];
 
 	const results = await Promise.all(
 		entries.map(async ([name, factory]) => {

package/src/tools/subagent-tool.ts

@@ -111,7 +111,7 @@ export function createSubagentTool<T extends TProperties>(
 
 				let contextFilePath: string | undefined;
 				if (passContext) {
-					const compactContext = this.session.getCompactContext?.();
+					const compactContext = this.session.subagentContext?.getCompactContext?.();
 					if (compactContext) {
 						contextFilePath = path.join(effectiveArtifactsDir, "context.md");
 						await Bun.write(contextFilePath, compactContext);
@@ -125,7 +125,7 @@ export function createSubagentTool<T extends TProperties>(
 					description: buildDescription(params),
 					index: 0,
 					id,
-					taskDepth: this.session.taskDepth ?? 0,
+					isSubagent: true,
 					modelOverride,
 					sessionFile,
 					persistArtifacts: !!artifactsDir,
@@ -134,13 +134,13 @@ export function createSubagentTool<T extends TProperties>(
 					enableLsp: false,
 					signal,
 					onProgress: emitProgress,
-					authStorage: this.session.authStorage,
-					modelRegistry: this.session.modelRegistry,
+					authStorage: this.session.subagentContext?.authStorage,
+					modelRegistry: this.session.subagentContext?.modelRegistry,
 					settings: this.session.settings,
 					contextFiles: this.session.contextFiles,
 					skills: this.session.skills,
 					promptTemplates: this.session.promptTemplates,
-					mcpManager: this.session.mcpManager,
+					mcpManager: this.session.subagentContext?.mcpManager,
 				});
 
 				if (tempArtifactsDir) {

package/src/tools/todo-write.ts

@@ -78,39 +78,6 @@ function normalizeTodos(items: Array<{ id?: string; content?: string; status?: s
 	});
 }
 
-function validateSequentialTodos(todos: TodoItem[]): { valid: boolean; error?: string } {
-	if (todos.length === 0) return { valid: true };
-
-	const firstIncompleteIndex = todos.findIndex(todo => todo.status !== "completed");
-	if (firstIncompleteIndex >= 0) {
-		for (let i = firstIncompleteIndex + 1; i < todos.length; i++) {
-			if (todos[i].status === "completed") {
-				return {
-					valid: false,
-					error: `Error: Cannot complete "${todos[i].content}" before completing "${todos[firstIncompleteIndex].content}". Todos must be completed sequentially.`,
-				};
-			}
-		}
-	}
-
-	const inProgressIndices = todos.reduce<number[]>((acc, todo, index) => {
-		if (todo.status === "in_progress") acc.push(index);
-		return acc;
-	}, []);
-
-	for (const idx of inProgressIndices) {
-		const hasPriorIncomplete = todos.slice(0, idx).some(t => t.status === "pending");
-		if (hasPriorIncomplete) {
-			return {
-				valid: false,
-				error: `Cannot start "${todos[idx].content}" while earlier tasks are still pending.`,
-			};
-		}
-	}
-
-	return { valid: true };
-}
-
 async function loadTodoFile(filePath: string): Promise<TodoFile | null> {
 	const file = Bun.file(filePath);
 	if (!(await file.exists())) return null;
@@ -168,10 +135,6 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<TodoWriteToolDetails>> {
 		const todos = normalizeTodos(params.todos ?? []);
-		const validation = validateSequentialTodos(todos);
-		if (!validation.valid) {
-			throw new Error(validation.error ?? "Todos must be completed sequentially.");
-		}
 		const updatedAt = Date.now();
 
 		const sessionFile = this.session.getSessionFile();

package/src/version.ts

@@ -0,0 +1,3 @@
+import { version } from "../package.json" with { type: "json" };
+
+export const VERSION: string = version;

package/src/prompts/system/subagent-submit-reminder.md

@@ -1,11 +0,0 @@
-<system-reminder>
-You stopped without calling submit_result. This is reminder {{retryCount}} of {{maxRetries}}.
-
-Your only available action now is to call submit_result. Choose one:
-- If task is complete: call submit_result with your result data
-- If task failed or was interrupted: call submit_result with status="aborted" and describe what happened
-
-Do NOT choose aborted if you can still complete the task through exploration (using available tools or repo context). If you must abort, include what you tried and the exact blocker.
-
-Do NOT output text without a tool call. You must call submit_result to finish.
-</system-reminder>

package/src/tools/jtd-to-json-schema.ts

@@ -1,247 +0,0 @@
-/**
- * Convert JSON Type Definition (JTD) to JSON Schema.
- *
- * JTD (RFC 8927) is a simpler schema format. This converter allows users to
- * write schemas in JTD and have them converted to JSON Schema for model APIs.
- *
- * @see https://jsontypedef.com/
- * @see https://datatracker.ietf.org/doc/html/rfc8927
- */
-
-type JTDPrimitive =
-	| "boolean"
-	| "string"
-	| "timestamp"
-	| "float32"
-	| "float64"
-	| "int8"
-	| "uint8"
-	| "int16"
-	| "uint16"
-	| "int32"
-	| "uint32";
-
-interface JTDType {
-	type: JTDPrimitive;
-}
-
-interface JTDEnum {
-	enum: string[];
-}
-
-interface JTDElements {
-	elements: JTDSchema;
-}
-
-interface JTDValues {
-	values: JTDSchema;
-}
-
-interface JTDProperties {
-	properties?: Record<string, JTDSchema>;
-	optionalProperties?: Record<string, JTDSchema>;
-}
-
-interface JTDDiscriminator {
-	discriminator: string;
-	mapping: Record<string, JTDProperties>;
-}
-
-interface JTDRef {
-	ref: string;
-}
-
-interface JTDEmpty {}
-
-type JTDSchema = JTDType | JTDEnum | JTDElements | JTDValues | JTDProperties | JTDDiscriminator | JTDRef | JTDEmpty;
-
-const primitiveMap: Record<JTDPrimitive, string> = {
-	boolean: "boolean",
-	string: "string",
-	timestamp: "string", // ISO 8601
-	float32: "number",
-	float64: "number",
-	int8: "integer",
-	uint8: "integer",
-	int16: "integer",
-	uint16: "integer",
-	int32: "integer",
-	uint32: "integer",
-};
-
-function isJTDType(schema: unknown): schema is JTDType {
-	return typeof schema === "object" && schema !== null && "type" in schema;
-}
-
-function isJTDEnum(schema: unknown): schema is JTDEnum {
-	return typeof schema === "object" && schema !== null && "enum" in schema;
-}
-
-function isJTDElements(schema: unknown): schema is JTDElements {
-	return typeof schema === "object" && schema !== null && "elements" in schema;
-}
-
-function isJTDValues(schema: unknown): schema is JTDValues {
-	return typeof schema === "object" && schema !== null && "values" in schema;
-}
-
-function isJTDProperties(schema: unknown): schema is JTDProperties {
-	return typeof schema === "object" && schema !== null && ("properties" in schema || "optionalProperties" in schema);
-}
-
-function isJTDDiscriminator(schema: unknown): schema is JTDDiscriminator {
-	return typeof schema === "object" && schema !== null && "discriminator" in schema;
-}
-
-function isJTDRef(schema: unknown): schema is JTDRef {
-	return typeof schema === "object" && schema !== null && "ref" in schema;
-}
-
-function convertSchema(schema: unknown): unknown {
-	if (schema === null || typeof schema !== "object") {
-		return {};
-	}
-
-	// Type form: { type: "string" } → { type: "string" }
-	if (isJTDType(schema)) {
-		const jsonType = primitiveMap[schema.type as JTDPrimitive];
-		if (!jsonType) {
-			return { type: schema.type };
-		}
-		return { type: jsonType };
-	}
-
-	// Enum form: { enum: ["a", "b"] } → { enum: ["a", "b"] }
-	if (isJTDEnum(schema)) {
-		return { enum: schema.enum };
-	}
-
-	// Elements form: { elements: { type: "string" } } → { type: "array", items: ... }
-	if (isJTDElements(schema)) {
-		return {
-			type: "array",
-			items: convertSchema(schema.elements),
-		};
-	}
-
-	// Values form: { values: { type: "string" } } → { type: "object", additionalProperties: ... }
-	if (isJTDValues(schema)) {
-		return {
-			type: "object",
-			additionalProperties: convertSchema(schema.values),
-		};
-	}
-
-	// Properties form: { properties: {...}, optionalProperties: {...} }
-	if (isJTDProperties(schema)) {
-		const properties: Record<string, unknown> = {};
-		const required: string[] = [];
-
-		// Required properties
-		if (schema.properties) {
-			for (const [key, value] of Object.entries(schema.properties)) {
-				properties[key] = convertSchema(value);
-				required.push(key);
-			}
-		}
-
-		// Optional properties
-		if (schema.optionalProperties) {
-			for (const [key, value] of Object.entries(schema.optionalProperties)) {
-				properties[key] = convertSchema(value);
-			}
-		}
-
-		const result: Record<string, unknown> = {
-			type: "object",
-			properties,
-			additionalProperties: false,
-		};
-
-		if (required.length > 0) {
-			result.required = required;
-		}
-
-		return result;
-	}
-
-	// Discriminator form: { discriminator: "type", mapping: { ... } }
-	if (isJTDDiscriminator(schema)) {
-		const oneOf: unknown[] = [];
-
-		for (const [tag, props] of Object.entries(schema.mapping)) {
-			const converted = convertSchema(props) as Record<string, unknown>;
-			// Add the discriminator property
-			const properties = (converted.properties || {}) as Record<string, unknown>;
-			properties[schema.discriminator] = { const: tag };
-
-			const required = ((converted.required as string[]) || []).slice();
-			if (!required.includes(schema.discriminator)) {
-				required.push(schema.discriminator);
-			}
-
-			oneOf.push({
-				...converted,
-				properties,
-				required,
-			});
-		}
-
-		return { oneOf };
-	}
-
-	// Ref form: { ref: "MyType" } → { $ref: "#/$defs/MyType" }
-	if (isJTDRef(schema)) {
-		return { $ref: `#/$defs/${schema.ref}` };
-	}
-
-	// Empty form: {} → {} (accepts anything)
-	return {};
-}
-
-/**
- * Detect if a schema is JTD format (vs JSON Schema).
- *
- * JTD schemas use: type (primitives), properties, optionalProperties, elements, values, enum, discriminator, ref
- * JSON Schema uses: type: "object", type: "array", items, additionalProperties, etc.
- */
-export function isJTDSchema(schema: unknown): boolean {
-	if (schema === null || typeof schema !== "object") {
-		return false;
-	}
-
-	const obj = schema as Record<string, unknown>;
-
-	// JTD-specific keywords
-	if ("elements" in obj) return true;
-	if ("values" in obj) return true;
-	if ("optionalProperties" in obj) return true;
-	if ("discriminator" in obj) return true;
-	if ("ref" in obj) return true;
-
-	// JTD type primitives (JSON Schema doesn't have int32, float64, etc.)
-	if ("type" in obj) {
-		const jtdPrimitives = ["timestamp", "float32", "float64", "int8", "uint8", "int16", "uint16", "int32", "uint32"];
-		if (jtdPrimitives.includes(obj.type as string)) {
-			return true;
-		}
-	}
-
-	// JTD properties form without type: "object" (JSON Schema requires it)
-	if ("properties" in obj && !("type" in obj)) {
-		return true;
-	}
-
-	return false;
-}
-
-/**
- * Convert JTD schema to JSON Schema.
- * If already JSON Schema, returns as-is.
- */
-export function jtdToJsonSchema(schema: unknown): unknown {
-	if (!isJTDSchema(schema)) {
-		return schema;
-	}
-	return convertSchema(schema);
-}