perstack 0.0.98 → 0.0.99

package/dist/bin/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "../chunk-D_gEzPfs.js";
-import { $ as never, A as startCommandInputSchema, At as defaultPerstackApiBaseUrl, B as ZodOptional$1, C as skipDelegates, Ct as defineLazy, D as stopRunByError, Dt as knownModels, E as stopRunByDelegate, Et as NEVER, F as isCoordinatorExpert, G as array$1, H as _instanceof, I as validateDelegation, J as discriminatedUnion, K as boolean, L as checkpointSchema, M as lockfileSchema, Mt as createId, N as jobSchema, O as stopRunByInteractiveTool, Ot as PerstackError, P as expertSchema, Q as looseObject, R as number$1, S as runSettingSchema, St as clone, T as startRun, Tt as $constructor, U as _null, V as _enum, W as any, X as lazy, Y as intersection, Z as literal, _ as proceedToInteractiveTools, _t as $ZodType, a as getFilteredEnv, at as strictObject, b as retry, bt as safeParse$1, c as createGeneralToolActivity, ct as union, d as continueToNextStep, dt as safeParseAsync$2, et as number, f as createRuntimeEvent, ft as datetime, g as parseExpertKey, gt as $ZodObject, h as finishToolCall, ht as meta$1, i as validateEventFilter, it as record, j as perstackConfigSchema, jt as defaultTimeout, k as runCommandInputSchema, kt as defaultMaxRetries, l as callTools, lt as unknown, m as finishMcpTools, mt as describe$1, n as parseWithFriendlyError, nt as optional, o as BASE_SKILL_PREFIX, ot as string, p as createStreamingEvent, pt as toJSONSchema, q as custom, r as createFilteredEventListener, rt as preprocess, s as createBaseToolActivity, st as tuple, t as createApiClient, tt as object$2, u as completeRun, ut as url, v as resolveToolResults, vt as parse$1, w as startGeneration, wt as normalizeParams, x as runParamsSchema, xt as safeParseAsync$1, y as resumeFromStop, yt as parseAsync, z as ZodIssueCode$1 } from "../dist-HjVmXsKn.js";
+import { $ as lazy, A as runCommandInputSchema, At as PerstackError, B as resolveModelTier, C as runSettingSchema, Ct as safeParse$1, D as stopRunByDelegate, Dt as normalizeParams, E as startRun, Et as defineLazy, F as expertSchema, G as _instanceof, H as ZodIssueCode$1, I as isCoordinatorExpert, J as array$1, K as _null, L as validateDelegation, M as perstackConfigSchema, Mt as defaultPerstackApiBaseUrl, N as lockfileSchema, Nt as defaultTimeout, O as stopRunByError, Ot as $constructor, P as jobSchema, Pt as createId, Q as intersection, R as checkpointSchema, S as runParamsSchema, St as parseAsync, T as startGeneration, Tt as clone, U as ZodOptional$1, V as number$1, W as _enum, X as custom, Y as boolean, Z as discriminatedUnion, _ as parseExpertKey, _t as describe$1, a as validateEventFilter, at as optional, b as resumeFromStop, bt as $ZodType, c as createBaseToolActivity, ct as strictObject, d as completeRun, dt as union, et as literal, f as continueToNextStep, ft as unknown, g as finishToolCall, gt as toJSONSchema, h as finishMcpTools, ht as datetime, i as createFilteredEventListener, it as object$2, j as startCommandInputSchema, jt as defaultMaxRetries, k as stopRunByInteractiveTool, kt as NEVER, l as createGeneralToolActivity, lt as string, m as createStreamingEvent, mt as safeParseAsync$2, n as parseWithFriendlyError, nt as never, o as getFilteredEnv, ot as preprocess, p as createRuntimeEvent, pt as url, q as any, r as truncateText$1, rt as number, s as BASE_SKILL_PREFIX, st as record, t as createApiClient, tt as looseObject, u as callTools, ut as tuple, v as proceedToInteractiveTools, vt as meta$1, w as skipDelegates, wt as safeParseAsync$1, x as retry, xt as parse$1, y as resolveToolResults, yt as $ZodObject, z as knownModels } from "../dist-Bm8UQoRz.js";
 import { t as require_token_error } from "../token-error-_b-fOBh2.js";
 import fs, { constants, lstat, mkdir, open, readFile, stat, writeFile } from "node:fs/promises";
 import path, { dirname, extname } from "node:path";
@@ -16299,7 +16299,7 @@ const EMPTY_COMPLETION_RESULT = { completion: {
 //#endregion
 //#region ../base/package.json
 var name$5 = "@perstack/base";
-var version$2 = "0.0.68";
+var version$2 = "0.0.70";
 
 //#endregion
 //#region ../base/src/tools/todo.ts
@@ -16428,8 +16428,8 @@ async function editTextFile(input) {
 	await applyFileEdit(validatedPath, newText, oldText);
 	return {
 		path: validatedPath,
-		newText,
-		oldText
+		newText: truncateText$1(newText),
+		oldText: truncateText$1(oldText)
 	};
 }
 function normalizeLineEndings(text) {
@@ -16479,7 +16479,7 @@ async function exec$2(input) {
 	if (input.stdout) output += stdout;
 	if (input.stderr) output += stderr;
 	if (!output.trim()) output = "Command executed successfully, but produced no output.";
-	return { output };
+	return { output: truncateText$1(output) };
 }
 function registerExec(server) {
 	server.registerTool("exec", {
@@ -16510,8 +16510,8 @@ function registerExec(server) {
 			} else if (error instanceof Error) message = error.message;
 			else message = "An unknown error occurred.";
 			const result = { error: message };
-			if (stdout && input.stdout) result.stdout = stdout;
-			if (stderr && input.stderr) result.stderr = stderr;
+			if (stdout && input.stdout) result.stdout = truncateText$1(stdout);
+			if (stderr && input.stderr) result.stderr = truncateText$1(stderr);
 			return { content: [{
 				type: "text",
 				text: JSON.stringify(result)
@@ -16616,7 +16616,7 @@ async function readTextFile(input) {
 	const toLine = to ?? lines.length;
 	return {
 		path,
-		content: lines.slice(fromLine, toLine).join("\n"),
+		content: truncateText$1(lines.slice(fromLine, toLine).join("\n")),
 		from: fromLine,
 		to: toLine
 	};
@@ -16784,7 +16784,7 @@ async function writeTextFile(input) {
 	await safeWriteFile(validatedPath, text);
 	return {
 		path: validatedPath,
-		text
+		text: truncateText$1(text)
 	};
 }
 function registerWriteTextFile(server) {
@@ -21116,9 +21116,179 @@ async function buildOutput(fetcher, options, filterOptions, storagePath) {
 	};
 }
 
+//#endregion
+//#region ../../packages/studio/src/client.ts
+function resolveApiKey(cliApiKey) {
+	const apiKey = cliApiKey ?? process.env.PERSTACK_API_KEY;
+	if (!apiKey) throw new PerstackError("PERSTACK_API_KEY is required. Set it as an environment variable or pass --api-key.");
+	return apiKey;
+}
+function createStudioClient(options) {
+	return createApiClient({
+		apiKey: options.apiKey,
+		baseUrl: options.baseUrl
+	});
+}
+
+//#endregion
+//#region ../../packages/studio/src/draft-handlers.ts
+async function expertListHandler(options) {
+	const result = await createStudioClient({
+		apiKey: resolveApiKey(options.apiKey),
+		baseUrl: options.baseUrl
+	}).expertDrafts.list({
+		filter: options.filter,
+		take: options.take,
+		skip: options.skip
+	});
+	if (!result.ok) throw new PerstackError(`Failed to list drafts: ${result.error.message}`);
+	const { data, meta } = result.data;
+	if (data.length === 0) {
+		console.log("No draft scopes found.");
+		return;
+	}
+	console.log(`Draft scopes (${meta.total} total):\n`);
+	for (const draft of data) {
+		const version = draft.currentVersion?.version ?? "-";
+		const refsCount = draft.draftRefs?.length ?? 0;
+		console.log(`  ${draft.name}`);
+		console.log(`    ID: ${draft.id}`);
+		console.log(`    Refs: ${refsCount}  Version: ${version}`);
+		console.log();
+	}
+}
+async function expertCreateHandler(scopeName, options) {
+	const result = await createStudioClient({
+		apiKey: resolveApiKey(options.apiKey),
+		baseUrl: options.baseUrl
+	}).expertDrafts.create({
+		scopeName,
+		applicationId: options.app
+	});
+	if (!result.ok) throw new PerstackError(`Failed to create draft: ${result.error.message}`);
+	const draft = result.data.data;
+	console.log(`Draft scope created:`);
+	console.log(`  Name: ${draft.name}`);
+	console.log(`  ID:   ${draft.id}`);
+}
+async function expertDeleteHandler(draftId, options) {
+	const result = await createStudioClient({
+		apiKey: resolveApiKey(options.apiKey),
+		baseUrl: options.baseUrl
+	}).expertDrafts.delete(draftId);
+	if (!result.ok) throw new PerstackError(`Failed to delete draft: ${result.error.message}`);
+	console.log(`Draft scope deleted: ${draftId}`);
+}
+async function expertPushHandler(draftId, options) {
+	const client = createStudioClient({
+		apiKey: resolveApiKey(options.apiKey),
+		baseUrl: options.baseUrl
+	});
+	const perstackConfig = await getPerstackConfig(options.config);
+	if (!perstackConfig.experts || Object.keys(perstackConfig.experts).length === 0) throw new PerstackError("No experts defined in perstack.toml");
+	const experts = Object.entries(perstackConfig.experts).map(([key, configExpert]) => configExpertToExpert(key, configExpert));
+	const result = await client.expertDrafts.refs.create(draftId, { experts });
+	if (!result.ok) throw new PerstackError(`Failed to push experts: ${result.error.message}`);
+	const { draftRef, definition } = result.data.data;
+	const expertKeys = Object.keys(definition.experts);
+	console.log(`Draft ref created:`);
+	console.log(`  Ref ID:  ${draftRef.id}`);
+	console.log(`  Experts: ${expertKeys.join(", ")}`);
+}
+async function expertRefsHandler(draftId, options) {
+	const result = await createStudioClient({
+		apiKey: resolveApiKey(options.apiKey),
+		baseUrl: options.baseUrl
+	}).expertDrafts.refs.list(draftId, {
+		take: options.take,
+		skip: options.skip
+	});
+	if (!result.ok) throw new PerstackError(`Failed to list refs: ${result.error.message}`);
+	const { data, meta } = result.data;
+	if (data.length === 0) {
+		console.log("No draft refs found.");
+		return;
+	}
+	console.log(`Draft refs (${meta.total} total):\n`);
+	for (const ref of data) {
+		console.log(`  ${ref.id}`);
+		console.log(`    Created: ${ref.createdAt}`);
+		console.log();
+	}
+}
+
+//#endregion
+//#region ../../packages/studio/src/publish-handlers.ts
+async function expertPublishHandler(scopeName, options) {
+	const result = await createStudioClient({
+		apiKey: resolveApiKey(options.apiKey),
+		baseUrl: options.baseUrl
+	}).experts.publish(scopeName);
+	if (!result.ok) throw new PerstackError(`Failed to publish: ${result.error.message}`);
+	console.log(`Expert scope published: ${scopeName}`);
+}
+async function expertUnpublishHandler(scopeName, options) {
+	const result = await createStudioClient({
+		apiKey: resolveApiKey(options.apiKey),
+		baseUrl: options.baseUrl
+	}).experts.unpublish(scopeName);
+	if (!result.ok) throw new PerstackError(`Failed to unpublish: ${result.error.message}`);
+	console.log(`Expert scope unpublished: ${scopeName}`);
+}
+async function expertYankHandler(key, options) {
+	const result = await createStudioClient({
+		apiKey: resolveApiKey(options.apiKey),
+		baseUrl: options.baseUrl
+	}).experts.yank(key);
+	if (!result.ok) throw new PerstackError(`Failed to yank: ${result.error.message}`);
+	console.log(`Expert version yanked: ${key}`);
+}
+
+//#endregion
+//#region ../../packages/studio/src/version-handlers.ts
+async function expertVersionHandler(draftId, refId, version, options) {
+	const client = createStudioClient({
+		apiKey: resolveApiKey(options.apiKey),
+		baseUrl: options.baseUrl
+	});
+	let readme;
+	if (options.readme) readme = await readFile(options.readme, "utf-8");
+	const result = await client.expertDrafts.refs.assignVersion(draftId, refId, {
+		version,
+		tag: options.tag,
+		readme
+	});
+	if (!result.ok) throw new PerstackError(`Failed to assign version: ${result.error.message}`);
+	const { scope, version: ver } = result.data.data;
+	console.log(`Version assigned:`);
+	console.log(`  Scope:   ${scope.name}`);
+	console.log(`  Version: ${ver.version}`);
+	console.log(`  Tags:    ${ver.tags.length > 0 ? ver.tags.join(", ") : "-"}`);
+}
+async function expertVersionsHandler(scopeName, options) {
+	const result = await createStudioClient({
+		apiKey: options.apiKey ?? process.env.PERSTACK_API_KEY,
+		baseUrl: options.baseUrl
+	}).experts.versions.list(scopeName);
+	if (!result.ok) throw new PerstackError(`Failed to list versions: ${result.error.message}`);
+	const { versions } = result.data.data;
+	if (versions.length === 0) {
+		console.log("No published versions found.");
+		return;
+	}
+	console.log(`Versions for ${scopeName}:\n`);
+	for (const ver of versions) {
+		const tags = ver.tags.length > 0 ? ` [${ver.tags.join(", ")}]` : "";
+		const yanked = ver.yanked ? " (yanked)" : "";
+		console.log(`  ${ver.version}${tags}${yanked}`);
+		console.log(`    Created: ${ver.createdAt}`);
+		console.log();
+	}
+}
+
 //#endregion
 //#region ../../packages/runtime/package.json
-var version$1 = "0.0.118";
+var version$1 = "0.0.121";
 
 //#endregion
 //#region ../../packages/runtime/src/helpers/usage.ts
@@ -77079,7 +77249,7 @@ function validateRuntimeVersion(experts) {
 //#endregion
 //#region ../../packages/runtime/src/helpers/setup-experts.ts
 async function setupExperts(setting, resolveExpertToRun) {
-	const resolveFn = resolveExpertToRun ?? (await import("../resolve-expert-CvhUOfWF.js")).resolveExpertToRun;
+	const resolveFn = resolveExpertToRun ?? (await import("../resolve-expert-C4hjjIyE.js")).resolveExpertToRun;
 	const { expertKey } = setting;
 	const experts = { ...setting.experts };
 	const clientOptions = {
@@ -90193,7 +90363,10 @@ async function resolvingToolResultLogic({ setting, checkpoint, step }) {
 			type: "toolResultPart",
 			toolCallId: toolResult.id,
 			toolName: toolCall?.toolName ?? toolResult.toolName,
-			contents: toolResult.result.filter((part) => part.type === "textPart" || part.type === "imageInlinePart" || part.type === "fileInlinePart")
+			contents: toolResult.result.filter((part) => part.type === "textPart" || part.type === "imageInlinePart" || part.type === "fileInlinePart").map((part) => part.type === "textPart" ? {
+				...part,
+				text: truncateText$1(part.text)
+			} : part)
 		};
 	}))] });
 }
@@ -90797,8 +90970,15 @@ var DelegationExecutor = class {
 	async executeSingleDelegation(delegation, parentSetting, parentContext, parentExpert, runFn, parentOptions) {
 		const { expert, toolCallId, toolName, query } = delegation;
 		const delegateRunId = createId();
+		let delegateModel = parentSetting.model;
+		const delegateExpert = parentSetting.experts?.[expert.key];
+		if (delegateExpert?.defaultModelTier) {
+			const tierModel = resolveModelTier(parentSetting.providerConfig.providerName, delegateExpert.defaultModelTier);
+			if (tierModel) delegateModel = tierModel;
+		}
 		const delegateSetting = {
 			...parentSetting,
+			model: delegateModel,
 			runId: delegateRunId,
 			expertKey: expert.key,
 			input: { text: query }
@@ -91195,7 +91375,8 @@ async function resolveRunContext(input) {
 			instruction: expert.instruction,
 			skills: expert.skills,
 			delegates: expert.delegates,
-			tags: expert.tags
+			tags: expert.tags,
+			defaultModelTier: expert.defaultModelTier
 		}];
 	}));
 	return {
@@ -91257,6 +91438,14 @@ async function runHandler(expertKey, query, options, handlerOptions) {
 		resumeFrom: input.options.resumeFrom,
 		expertKey: input.expertKey
 	});
+	let resolvedModel = model;
+	if (!input.options.model) {
+		const expertConfig = perstackConfig.experts?.[input.expertKey];
+		if (expertConfig?.defaultModelTier) {
+			const tierModel = resolveModelTier(providerConfig.providerName, expertConfig.defaultModelTier);
+			if (tierModel) resolvedModel = tierModel;
+		}
+	}
 	if (handlerOptions?.additionalEnv) Object.assign(env, handlerOptions.additionalEnv(env));
 	const lockfile = handlerOptions.lockfile;
 	await run({
@@ -91266,7 +91455,7 @@ async function runHandler(expertKey, query, options, handlerOptions) {
 			expertKey: input.expertKey,
 			input: input.options.interactiveToolCallResult ? parseInteractiveToolCallResultJson(input.query) ?? (checkpoint ? parseInteractiveToolCallResult(input.query, checkpoint) : { text: input.query }) : { text: input.query },
 			experts,
-			model,
+			model: resolvedModel,
 			providerConfig,
 			reasoningBudget: input.options.reasoningBudget ?? perstackConfig.reasoningBudget,
 			maxRetries: input.options.maxRetries ?? perstackConfig.maxRetries,
@@ -119490,6 +119679,14 @@ async function startHandler(expertKey, query, options, handlerOptions) {
 		console.error(`Checkpoint expert key ${currentCheckpoint.expert.key} does not match input expert key ${selection.expertKey}`);
 		return;
 	}
+	let resolvedModel = model;
+	if (!input.options.model) {
+		const expertConfig = perstackConfig.experts?.[selection.expertKey];
+		if (expertConfig?.defaultModelTier) {
+			const tierModel = resolveModelTier(providerConfig.providerName, expertConfig.defaultModelTier);
+			if (tierModel) resolvedModel = tierModel;
+		}
+	}
 	const lockfile = handlerOptions.lockfile;
 	let currentQuery = input.query ?? null;
 	let currentJobId = currentCheckpoint?.jobId ?? input.options.jobId ?? createId();
@@ -119504,7 +119701,7 @@ async function startHandler(expertKey, query, options, handlerOptions) {
 			query: currentQuery ?? void 0,
 			config: {
 				runtimeVersion,
-				model,
+				model: resolvedModel,
 				maxRetries,
 				timeout,
 				contextWindowUsage: currentCheckpoint?.contextWindowUsage ?? 0
@@ -119519,7 +119716,7 @@ async function startHandler(expertKey, query, options, handlerOptions) {
 				expertKey: selection.expertKey,
 				input: isNextQueryInteractiveToolResult && currentCheckpoint ? parseInteractiveToolCallResult(resolvedQuery, currentCheckpoint) : { text: resolvedQuery },
 				experts,
-				model,
+				model: resolvedModel,
 				providerConfig,
 				reasoningBudget: input.options.reasoningBudget ?? perstackConfig.reasoningBudget,
 				maxRetries: input.options.maxRetries ?? perstackConfig.maxRetries,
@@ -119556,7 +119753,7 @@ async function startHandler(expertKey, query, options, handlerOptions) {
 //#endregion
 //#region package.json
 var name = "perstack";
-var version = "0.0.98";
+var version = "0.0.99";
 var description = "PerStack CLI";
 
 //#endregion
@@ -119592,6 +119789,59 @@ program.command("install").description("Generate perstack.lock with tool definit
 		envPath: options.envPath
 	});
 });
+function getParentOptions(cmd) {
+	const parent = cmd.parent?.opts();
+	return {
+		apiKey: parent?.apiKey,
+		baseUrl: parent?.baseUrl
+	};
+}
+const expertCmd = program.command("expert").description("Manage experts on Perstack API").option("--api-key <key>", "Perstack API key (default: PERSTACK_API_KEY env)").option("--base-url <url>", "Custom API base URL");
+expertCmd.command("list").description("List draft scopes").option("--filter <name>", "Filter by name").option("--take <n>", "Limit results", Number.parseInt).option("--skip <n>", "Offset", Number.parseInt).action(async function(options) {
+	await expertListHandler({
+		...getParentOptions(this),
+		...options
+	});
+});
+expertCmd.command("create").description("Create a new draft scope").argument("<scopeName>", "Expert scope name").requiredOption("--app <id>", "Application ID").action(async function(scopeName, options) {
+	await expertCreateHandler(scopeName, {
+		...getParentOptions(this),
+		...options
+	});
+});
+expertCmd.command("delete").description("Delete a draft scope").argument("<draftId>", "Draft scope ID").action(async function(draftId) {
+	await expertDeleteHandler(draftId, getParentOptions(this));
+});
+expertCmd.command("push").description("Push local expert definitions to a draft ref").argument("<draftId>", "Draft scope ID").option("--config <path>", "Path to perstack.toml config file").action(async function(draftId, options) {
+	await expertPushHandler(draftId, {
+		...getParentOptions(this),
+		...options
+	});
+});
+expertCmd.command("refs").description("List draft refs for a draft scope").argument("<draftId>", "Draft scope ID").option("--take <n>", "Limit results", Number.parseInt).option("--skip <n>", "Offset", Number.parseInt).action(async function(draftId, options) {
+	await expertRefsHandler(draftId, {
+		...getParentOptions(this),
+		...options
+	});
+});
+expertCmd.command("version").description("Assign a version to a draft ref").argument("<draftId>", "Draft scope ID").argument("<refId>", "Draft ref ID").argument("<version>", "Semantic version (e.g., 1.0.0)").option("--tag <tag>", "Version tag (e.g., latest)").option("--readme <path>", "Path to README file").action(async function(draftId, refId, version, options) {
+	await expertVersionHandler(draftId, refId, version, {
+		...getParentOptions(this),
+		...options
+	});
+});
+expertCmd.command("versions").description("List published versions for an expert scope").argument("<scopeName>", "Expert scope name").action(async function(scopeName) {
+	await expertVersionsHandler(scopeName, getParentOptions(this));
+});
+expertCmd.command("publish").description("Make an expert scope public").argument("<scopeName>", "Expert scope name").action(async function(scopeName) {
+	await expertPublishHandler(scopeName, getParentOptions(this));
+});
+expertCmd.command("unpublish").description("Make an expert scope private").argument("<scopeName>", "Expert scope name").action(async function(scopeName) {
+	await expertUnpublishHandler(scopeName, getParentOptions(this));
+});
+expertCmd.command("yank").description("Deprecate a specific expert version").argument("<key>", "Expert key with version (e.g., my-expert@1.0.0)").action(async function(key) {
+	await expertYankHandler(key, getParentOptions(this));
+});
 program.parseAsync().catch((error) => {
 	if (error instanceof PerstackError) {
 		console.error(error.message);