@vibe-lark/larkpal 0.1.74 → 0.1.76

package/dist/main.mjs

@@ -3464,6 +3464,139 @@ function createChatAuthRouter() {
 	return router;
 }
 //#endregion
+//#region src/gateway/runtime-context.ts
+const CLAUDE_MD_START = "<!-- LARKPAL_RUNTIME_INSTRUCTIONS_START -->";
+const CLAUDE_MD_END = "<!-- LARKPAL_RUNTIME_INSTRUCTIONS_END -->";
+function materializeRuntimeContext(params) {
+	const instructions = normalizeRuntimeInstructions(params.instructions);
+	const skills = normalizeRuntimeSkills(params.skills);
+	if (instructions.length === 0 && skills.length === 0) return void 0;
+	return {
+		instructions: instructions.length > 0 ? writeRuntimeInstructions(params.cwd, instructions) : [],
+		skills: skills.map((skill) => writeRuntimeSkill(params.cwd, skill))
+	};
+}
+function normalizeRuntimeInstructions(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+		const record = item;
+		const id = readNonEmptyString(record.id);
+		const content = readNonEmptyString(record.content);
+		if (!id || !content) return null;
+		return {
+			id,
+			content,
+			scope: readScope(record.scope),
+			version: readNonEmptyString(record.version)
+		};
+	}).filter((item) => item != null);
+}
+function normalizeRuntimeSkills(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+		const record = item;
+		const id = readNonEmptyString(record.id);
+		const content = readNonEmptyString(record.content) || readNonEmptyString(record.skillMarkdown);
+		if (!id || !content) return null;
+		return {
+			id,
+			content,
+			scope: readScope(record.scope),
+			version: readNonEmptyString(record.version),
+			name: readNonEmptyString(record.name),
+			description: readNonEmptyString(record.description)
+		};
+	}).filter((item) => item != null);
+}
+function writeRuntimeInstructions(cwd, instructions) {
+	const filePath = join(cwd, "CLAUDE.md");
+	const body = [
+		CLAUDE_MD_START,
+		"# LarkPal Runtime Instructions",
+		"",
+		"The following instructions were injected by LarkPal for this agent session. Treat them as runtime context, not as user message content.",
+		"",
+		...instructions.flatMap((instruction) => [
+			`## ${instruction.id}`,
+			"",
+			instruction.content.trim(),
+			""
+		]),
+		CLAUDE_MD_END,
+		""
+	].join("\n");
+	const next = replaceManagedBlock(existsSync(filePath) ? readFileSync(filePath, "utf-8") : "", body);
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, next, "utf-8");
+	return instructions.map((instruction) => ({
+		id: instruction.id,
+		scope: instruction.scope ?? "request",
+		hash: hashContent(instruction.content),
+		version: instruction.version,
+		path: "CLAUDE.md"
+	}));
+}
+function writeRuntimeSkill(cwd, skill) {
+	const relativePath = `.claude/skills/${sanitizePathSegment(skill.id)}/SKILL.md`;
+	const filePath = join(cwd, relativePath);
+	const content = buildSkillContent(skill);
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, content, "utf-8");
+	return {
+		id: skill.id,
+		scope: skill.scope ?? "request",
+		hash: hashContent(content),
+		version: skill.version,
+		path: relativePath
+	};
+}
+function buildSkillContent(skill) {
+	const content = skill.content.trim();
+	if (content.startsWith("---")) return `${content}\n`;
+	const name = skill.name || skill.id;
+	const description = skill.description || `Runtime skill injected by LarkPal: ${skill.id}`;
+	return [
+		"---",
+		`name: ${yamlScalar(name)}`,
+		`description: ${yamlScalar(description)}`,
+		"---",
+		"",
+		content,
+		""
+	].join("\n");
+}
+function replaceManagedBlock(current, managedBlock) {
+	const start = current.indexOf(CLAUDE_MD_START);
+	const end = current.indexOf(CLAUDE_MD_END);
+	if (start !== -1 && end !== -1 && end > start) {
+		const before = current.slice(0, start).trimEnd();
+		const after = current.slice(end + 41).trimStart();
+		return [
+			before,
+			managedBlock.trimEnd(),
+			after
+		].filter(Boolean).join("\n\n") + "\n";
+	}
+	return [current.trimEnd(), managedBlock.trimEnd()].filter(Boolean).join("\n\n") + "\n";
+}
+function hashContent(content) {
+	return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function sanitizePathSegment(value) {
+	return value.replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+$/, "skill") || "skill";
+}
+function readNonEmptyString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readScope(value) {
+	return value === "app" || value === "session" || value === "request" ? value : "request";
+}
+function yamlScalar(value) {
+	return JSON.stringify(value);
+}
+//#endregion
 //#region src/gateway/agent-context.ts
 const SENSITIVE_KEY_PATTERN = /(authorization|cookie|token|api[-_]?key|secret|password|credential)/i;
 const SAFE_KEY_PATTERN = /^(file[-_]?token|drive[-_]?file[-_]?token|doc[-_]?token|sheet[-_]?token|wiki[-_]?token|node[-_]?token)$/i;
@@ -3505,11 +3638,17 @@ function buildAgentRuntimeConfig(input) {
 	const userId = requireContextField(input.identity?.userId || input.identity?.openId, "userId");
 	const scenarioId = getScenarioId(input.scenarioId, input.metadata);
 	const cwd = resolveAgentCwd(sessionId, input.cwd);
+	const runtimeContext = materializeRuntimeContext({
+		cwd,
+		instructions: input.runtimeInstructions,
+		skills: input.runtimeSkills
+	});
 	const metadata = buildRunMetadata(input.metadata, {
 		conversationId,
 		traceId,
 		entrypoint: input.entrypoint,
-		scenarioId
+		scenarioId,
+		runtimeContext
 	});
 	const authHeaders = buildAuthHeaders({
 		tenantKey,
@@ -3541,6 +3680,7 @@ function buildAgentRuntimeConfig(input) {
 		authHeaders,
 		attachments: input.attachments,
 		sourceArtifacts: input.sourceArtifacts,
+		runtimeContext,
 		llmConfig: input.llmConfig,
 		policy,
 		metadata
@@ -3559,6 +3699,7 @@ function buildAgentRuntimeConfig(input) {
 		authHeaders,
 		attachments: input.attachments,
 		sourceArtifacts: input.sourceArtifacts,
+		runtimeContext,
 		llmConfig: input.llmConfig,
 		policy,
 		requestContext,
@@ -3644,6 +3785,7 @@ function buildRunInputAuditMetadata(config) {
 	const metadata = {};
 	if (config.attachments !== void 0) metadata.attachments = summarizeForAudit(config.attachments);
 	if (config.sourceArtifacts !== void 0) metadata.sourceArtifacts = summarizeForAudit(config.sourceArtifacts);
+	if (config.runtimeContext !== void 0) metadata.runtimeContext = config.runtimeContext;
 	return metadata;
 }
 function buildRuntimeEventAuditMetadata(event) {
@@ -3732,7 +3874,8 @@ function buildRunMetadata(metadata, context) {
 		conversationId: context.conversationId,
 		traceId: context.traceId,
 		entrypoint: context.entrypoint,
-		...context.scenarioId ? { scenarioId: context.scenarioId } : {}
+		...context.scenarioId ? { scenarioId: context.scenarioId } : {},
+		...context.runtimeContext ? { runtimeContext: context.runtimeContext } : {}
 	};
 }
 function buildAuditMetadata(context, metadata) {
@@ -3818,6 +3961,7 @@ function serializeChatRun(run) {
 		completedAt: run.completedAt,
 		finalStatus: run.finalStatus,
 		error: run.error,
+		runtimeError: run.runtimeError,
 		textLength: run.text.length,
 		finalText: run.status === "running" ? void 0 : run.text || void 0,
 		lastEventAt: run.lastEventAt,
@@ -3985,6 +4129,7 @@ function appendRunStatusMessage(run, messageStore) {
 			runtimeEventType: "run-status",
 			finalStatus: run.finalStatus,
 			errorMessage: run.error,
+			runtimeError: run.runtimeError,
 			staleReason: run.staleReason
 		}
 	}, "[stream] 保存 run status 消息失败");
@@ -4351,6 +4496,107 @@ function buildToolResultPayload(result, resultSummary) {
 		result: resultSummary
 	};
 }
+function normalizeRuntimeResult(result) {
+	if (!result.isError) return {
+		status: "completed",
+		finalStatus: result.subtype,
+		isError: false,
+		finalText: result.result
+	};
+	const error = buildRuntimeErrorSummary(result.subtype, result.result);
+	return {
+		status: "failed",
+		finalStatus: error.code,
+		isError: true,
+		finalText: result.result || error.message,
+		error
+	};
+}
+function buildRuntimeErrorSummary(subtype, result) {
+	const message = normalizeWhitespace(result || `Runtime execution failed: ${subtype}`);
+	const httpStatus = extractHttpStatus(message);
+	const requestId = extractRequestId(message);
+	const providerMessage = extractProviderMessage(message);
+	return {
+		isError: true,
+		code: detectRuntimeErrorCode(subtype, message),
+		subtype,
+		httpStatus,
+		message: truncateRuntimeErrorMessage(message),
+		providerMessage: providerMessage ? truncateRuntimeErrorMessage(providerMessage) : void 0,
+		requestId
+	};
+}
+function detectRuntimeErrorCode(subtype, message) {
+	if (/\bprovider_response_error\b/i.test(message)) return "provider_response_error";
+	if (/\bapi_error\b/i.test(message) || /^API Error:/i.test(message)) return "api_error";
+	if (subtype && subtype !== "success") return subtype;
+	return "error_during_execution";
+}
+function extractHttpStatus(message) {
+	const match = message.match(/\b(?:API Error:|provider[^:]*:)?\s*(\d{3})\b/i);
+	if (!match?.[1]) return void 0;
+	const status = Number.parseInt(match[1], 10);
+	return Number.isFinite(status) ? status : void 0;
+}
+function extractRequestId(message) {
+	return message.match(/\bRequest id:\s*([A-Za-z0-9._:-]+)/i)?.[1];
+}
+function extractProviderMessage(message) {
+	const parsedMessage = extractJsonErrorMessage(message);
+	if (parsedMessage) return parsedMessage;
+	const jsonMessage = message.match(/"message"\s*:\s*"([^"]+)"/);
+	if (jsonMessage?.[1]) return unescapeJsonFragment(jsonMessage[1]);
+	const requestIdIndex = message.search(/\bRequest id:/i);
+	if (requestIdIndex > 0) {
+		const prefix = message.slice(0, requestIdIndex).trim();
+		const sentenceStart = Math.max(prefix.lastIndexOf("}"), prefix.lastIndexOf(":"));
+		return prefix.slice(sentenceStart + 1).trim() || void 0;
+	}
+}
+function extractJsonErrorMessage(message) {
+	const start = message.indexOf("{");
+	const end = message.lastIndexOf("}");
+	if (start < 0 || end <= start) return void 0;
+	try {
+		const topMessage = readNestedString(JSON.parse(message.slice(start, end + 1)), ["error", "message"]);
+		if (!topMessage) return void 0;
+		return extractNestedJsonErrorMessage(topMessage) || topMessage;
+	} catch {
+		return;
+	}
+}
+function extractNestedJsonErrorMessage(message) {
+	const start = message.indexOf("{");
+	const end = message.lastIndexOf("}");
+	if (start < 0 || end <= start) return void 0;
+	try {
+		return readNestedString(JSON.parse(message.slice(start, end + 1)), ["error", "message"]);
+	} catch {
+		return;
+	}
+}
+function readNestedString(value, path) {
+	let current = value;
+	for (const key of path) {
+		if (!current || typeof current !== "object" || Array.isArray(current)) return void 0;
+		current = current[key];
+	}
+	return typeof current === "string" ? current : void 0;
+}
+function unescapeJsonFragment(value) {
+	try {
+		return JSON.parse(`"${value.replace(/"/g, "\\\"")}"`);
+	} catch {
+		return value.replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+	}
+}
+function normalizeWhitespace(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function truncateRuntimeErrorMessage(value) {
+	return value.length > 2e3 ? `${value.slice(0, 2e3)}...` : value;
+}
 function readStringField(value, key) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
 	const field = value[key];
@@ -4470,6 +4716,8 @@ function createChatRouter(config) {
 		const scenarioId = getScenarioId(body.options?.scenarioId, body.options?.metadata);
 		const attachments = getRunInputValue(body.attachments, body.options?.attachments, body.options?.metadata?.attachments);
 		const sourceArtifacts = getRunInputValue(body.sourceArtifacts, body.source_artifacts, body.options?.sourceArtifacts, body.options?.source_artifacts, body.options?.metadata?.sourceArtifacts, body.options?.metadata?.source_artifacts);
+		const runtimeInstructions = getRunInputValue(body.runtimeInstructions, body.runtime_instructions, body.options?.runtimeInstructions, body.options?.runtime_instructions, body.options?.metadata?.runtimeInstructions, body.options?.metadata?.runtime_instructions);
+		const runtimeSkills = getRunInputValue(body.runtimeSkills, body.runtime_skills, body.options?.runtimeSkills, body.options?.runtime_skills, body.options?.metadata?.runtimeSkills, body.options?.metadata?.runtime_skills);
 		log$30.info("[stream] 收到流式对话请求", {
 			userId,
 			sessionId,
@@ -4478,6 +4726,8 @@ function createChatRouter(config) {
 			scenarioId,
 			hasAttachments: attachments !== void 0,
 			hasSourceArtifacts: sourceArtifacts !== void 0,
+			hasRuntimeInstructions: runtimeInstructions !== void 0,
+			hasRuntimeSkills: runtimeSkills !== void 0,
 			promptLength: body.prompt.length
 		});
 		if (!sessionId) {
@@ -4525,6 +4775,8 @@ function createChatRouter(config) {
 			model: process.env.CLAUDE_MODEL || void 0,
 			attachments,
 			sourceArtifacts,
+			runtimeInstructions,
+			runtimeSkills,
 			policy: body.options?.policy,
 			metadata: body.options?.metadata,
 			identity: {
@@ -4564,10 +4816,7 @@ function createChatRouter(config) {
 					requestId,
 					traceId,
 					scenarioId,
-					...buildRunInputAuditMetadata({
-						attachments,
-						sourceArtifacts
-					})
+					...buildRunInputAuditMetadata(runtimeConfig)
 				}
 			});
 		} catch (err) {
@@ -4782,9 +5031,15 @@ function createChatRouter(config) {
 			onResult: async (result) => {
 				if (run.status !== "running") return;
 				recordRunEvent(run, "result");
-				const finalText = run.text.trim() ? run.text : result.result || "";
+				const normalizedResult = normalizeRuntimeResult(result);
+				const partialText = run.text.trim() ? run.text : void 0;
+				const finalText = normalizedResult.isError ? normalizedResult.finalText || partialText || "" : partialText || normalizedResult.finalText || "";
 				run.text = finalText;
-				await markRunTerminal(run, messageStore, result.isError ? "failed" : "completed", { finalStatus: result.subtype });
+				run.runtimeError = normalizedResult.error;
+				await markRunTerminal(run, messageStore, normalizedResult.status, {
+					finalStatus: normalizedResult.finalStatus,
+					error: normalizedResult.error?.message
+				});
 				await cleanupTerminalRunProcess(run, processManager, "result");
 				await queueRunMessage(run, messageStore, {
 					sessionId,
@@ -4799,15 +5054,21 @@ function createChatRouter(config) {
 						traceId,
 						requestId,
 						scenarioId,
-						finalStatus: result.subtype,
-						isError: result.isError
+						finalStatus: normalizedResult.finalStatus,
+						isError: normalizedResult.isError,
+						runtimeError: normalizedResult.error,
+						partialText
 					}
 				}, "[stream] 保存 assistant 消息失败");
 				broadcastRunEvent(run, "done", {
 					sessionId,
 					runId: run.runId,
-					result: result.subtype,
+					result: normalizedResult.finalStatus,
+					finalStatus: normalizedResult.finalStatus,
+					isError: normalizedResult.isError,
+					error: normalizedResult.error,
 					text: finalText,
+					partialText,
 					durationMs: result.durationMs,
 					totalCostUsd: result.totalCostUsd,
 					numTurns: result.numTurns
@@ -4817,7 +5078,8 @@ function createChatRouter(config) {
 				log$30.info("[stream] 对话完成", {
 					sessionId,
 					runId: run.runId,
-					result: result.subtype,
+					result: normalizedResult.finalStatus,
+					isError: normalizedResult.isError,
 					textLength: finalText.length,
 					durationMs: result.durationMs
 				});
@@ -4826,6 +5088,9 @@ function createChatRouter(config) {
 					metadata: {
 						runId: run.runId,
 						subtype: result.subtype,
+						finalStatus: normalizedResult.finalStatus,
+						isError: normalizedResult.isError,
+						runtimeError: normalizedResult.error,
 						totalCostUsd: result.totalCostUsd,
 						numTurns: result.numTurns,
 						traceId,
@@ -6110,6 +6375,8 @@ async function handleExecute(req, res, processManager) {
 	const scenarioId = getScenarioId(body.scenarioId || body.scenario_id, body.metadata);
 	const attachments = getRunInputValue(body.attachments, body.metadata?.attachments);
 	const sourceArtifacts = getRunInputValue(body.sourceArtifacts, body.source_artifacts, body.metadata?.sourceArtifacts, body.metadata?.source_artifacts);
+	const runtimeInstructions = getRunInputValue(body.runtimeInstructions, body.runtime_instructions, body.metadata?.runtimeInstructions, body.metadata?.runtime_instructions);
+	const runtimeSkills = getRunInputValue(body.runtimeSkills, body.runtime_skills, body.metadata?.runtimeSkills, body.metadata?.runtime_skills);
 	const identity = resolveExecuteIdentity(req, body);
 	const missingIdentityFields = getMissingIdentityFields(identity);
 	if (missingIdentityFields.length > 0) {
@@ -6156,6 +6423,8 @@ async function handleExecute(req, res, processManager) {
 			authHeaders: body.auth_headers,
 			attachments,
 			sourceArtifacts,
+			runtimeInstructions,
+			runtimeSkills,
 			policy: body.policy,
 			metadata: body.metadata,
 			identity
@@ -6284,6 +6553,8 @@ async function handleBatchExecute(req, res, processManager) {
 	const scenarioId = getScenarioId(body.scenarioId || body.scenario_id, body.metadata);
 	const batchAttachments = getRunInputValue(body.attachments, body.metadata?.attachments);
 	const batchSourceArtifacts = getRunInputValue(body.sourceArtifacts, body.source_artifacts, body.metadata?.sourceArtifacts, body.metadata?.source_artifacts);
+	const batchRuntimeInstructions = getRunInputValue(body.runtimeInstructions, body.runtime_instructions, body.metadata?.runtimeInstructions, body.metadata?.runtime_instructions);
+	const batchRuntimeSkills = getRunInputValue(body.runtimeSkills, body.runtime_skills, body.metadata?.runtimeSkills, body.metadata?.runtime_skills);
 	const concurrency = body.concurrency ?? 3;
 	const taskIds = [];
 	const taskConfigs = [];
@@ -6299,6 +6570,8 @@ async function handleBatchExecute(req, res, processManager) {
 			};
 			const taskAttachments = getRunInputValue(task.attachments, task.metadata?.attachments, batchAttachments);
 			const taskSourceArtifacts = getRunInputValue(task.sourceArtifacts, task.source_artifacts, task.metadata?.sourceArtifacts, task.metadata?.source_artifacts, batchSourceArtifacts);
+			const taskRuntimeInstructions = getRunInputValue(task.runtimeInstructions, task.runtime_instructions, task.metadata?.runtimeInstructions, task.metadata?.runtime_instructions, batchRuntimeInstructions);
+			const taskRuntimeSkills = getRunInputValue(task.runtimeSkills, task.runtime_skills, task.metadata?.runtimeSkills, task.metadata?.runtime_skills, batchRuntimeSkills);
 			const config = buildAgentRuntimeConfig({
 				requestId: `${batchRequestId}:${index}`,
 				traceId,
@@ -6311,6 +6584,8 @@ async function handleBatchExecute(req, res, processManager) {
 				authHeaders: body.auth_headers,
 				attachments: taskAttachments,
 				sourceArtifacts: taskSourceArtifacts,
+				runtimeInstructions: taskRuntimeInstructions,
+				runtimeSkills: taskRuntimeSkills,
 				policy: body.policy,
 				metadata: taskMetadata,
 				identity

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-lark/larkpal",
-  "version": "0.1.74",
+  "version": "0.1.76",
   "description": "LarkPal - Lark/Feishu bot service",
   "type": "module",
   "main": "./dist/main.mjs",
@@ -21,9 +21,22 @@
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
+  "packageManager": "pnpm@10.32.1",
   "engines": {
     "node": ">=22"
   },
+  "scripts": {
+    "start": "node --env-file=.env bin/larkpal.js",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "sit:larkpal-agent": "node scripts/sit/larkpal-agent-0.1.9-sit.mjs",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check src/**/*.ts"
+  },
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.60.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -56,17 +69,5 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.32.1",
     "vitest": "^4.1.1"
-  },
-  "scripts": {
-    "start": "node --env-file=.env bin/larkpal.js",
-    "build": "tsdown",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
-    "sit:larkpal-agent": "node scripts/sit/larkpal-agent-0.1.9-sit.mjs",
-    "typecheck": "tsc --noEmit",
-    "format": "prettier --write src/**/*.ts",
-    "format:check": "prettier --check src/**/*.ts"
   }
-}
+}