@qilin-agent/sidebar-opens 0.0.0-stage → 3.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kkutysllb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,43 @@
+# Bilingual-pair consistency record for README.md (docs/i18n/README.md): per heading
+# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
+# After editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/host/sidebar-opens/README.md
+/:
+  en: 96e86d8f1f2fd2f1
+  zh: 133353bfc33d5536
+/qilin-agent-sidebar-opens:
+  en: 97611fa28977717d
+  zh: 1017316dca27570e
+/qilin-agent-sidebar-opens/summary:
+  en: 96a42ba67afac8e4
+  zh: 243c7814e2a5bf9c
+/qilin-agent-sidebar-opens/table-of-contents:
+  en: 368556c7719717f4
+  zh: 28c8e90d2b051204
+/qilin-agent-sidebar-opens/the-tool:
+  en: dca03510399b377d
+  zh: 1a8f294023a8de74
+/qilin-agent-sidebar-opens/delivery:
+  en: ae476c467a05ca97
+  zh: 35842db297712f12
+/qilin-agent-sidebar-opens/model-experience:
+  en: 215e7ba838619b7b
+  zh: a311da3843709f90
+/qilin-agent-sidebar-opens/model-experience/sidebar-open:
+  en: 5c385332963c706b
+  zh: 5c385332963c706b
+/qilin-agent-sidebar-opens/model-experience/sidebar-open/what-the-model-sees:
+  en: 4b72f8439fbadea0
+  zh: ed9723a23ff7f0ab
+/qilin-agent-sidebar-opens/model-experience/sidebar-open/token-effect:
+  en: 2f7bd9b9f7f01d36
+  zh: 669d25591716baab
+/qilin-agent-sidebar-opens/model-experience/sidebar-open/kv-cache-effect:
+  en: 5d72f926299aaba9
+  zh: 684933cc36fe0ac6
+/qilin-agent-sidebar-opens/known-limitations-and-deferred-work:
+  en: b703f660b903481d
+  zh: f453516d12a6f6bf
+/qilin-agent-sidebar-opens/known-limitations-and-deferred-work/dev-note:
+  en: e67f633dc6fe7773
+  zh: 4e706f1b2b984e63

package/README.md

@@ -1,3 +1,69 @@
-# Temporary Holding Version
+---
+description: "Model-facing requests to open a file or an http(s) page in the Session's Sidebar."
+kind: "package-reference"
+---
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# @qilin-agent/sidebar-opens
+
+English | [中文](README.zh.md)
+
+## Summary
+
+`sidebar_open` lets the model show something instead of describing it: one existing file, or one http(s) page. The request travels as a Host Remote stream (`sidebarOpens.watch`) to [`@qilin-agent/client-ui-agent-opens`](../../client/ui-agent-opens/README.md), which opens the Session's own Sidebar on it. Delivery is transient: a request is consumed on send while a view is attached, and otherwise waits in a bounded per-Session queue a later attachment replays.
+
+## Table of Contents
+
+- [The tool](#the-tool)
+- [Delivery](#delivery)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+## The tool
+
+Exactly one of `path` or `url` is required.
+
+- `path` accepts an absolute path or one relative to the Session working directory, and is verified through the Session filesystem before the request is made: a path that does not resolve, or that names something other than a regular file, fails the call rather than opening a broken tab.
+- `url` accepts `http://` and `https://` only. Anything else is refused, so a `file://` the model composed cannot reach the browser's opener.
+- The title is the file's basename or the page's host.
+
+The result reports the resolved target and whether an attached view took it now. The Host-minted request identity stays internal.
+
+## Delivery
+
+`watch(sessionId, signal)` yields what queued while nothing was attached and then every request as it arrives. A second watcher for the same Session takes over: the newest view is the one the user is looking at. `enqueue` answers whether an attached view consumed the request; with none it queues, dropping the oldest request past `maxQueued` so a Session nobody watches cannot accumulate requests without end.
+
+## Model Experience
+
+### sidebar_open
+
+#### What the model sees
+
+The [sidebar_open schema](../../../docs/tool-catalog.md#sidebar_open) offers one file or one http(s) page: "Open one file or one http(s) page in the Sidebar the user is viewing this Session in. Use it when the user asked to see something: a file you produced, a file worth reading beside the conversation, or a page you found. Pass exactly one of `path` (a file that already exists) or `url`. The file opens in the document preview and the page in the built-in browser; both appear beside the conversation rather than leaving the application." Results are one line — the target opened, or the target waiting for the Session's Sidebar — with `kind`, `target`, `title`, and `delivered`.
+
+#### Token effect
+
+Two parameters and one small result per call. Nothing here is added to the system prompt.
+
+#### KV Cache effect
+
+None directly. A call and its result append to the Session like any other tool turn; the cache moves the way it does for any tool call.
+
+## Known Limitations and Deferred Work
+
+- **Folders are not openable.** The Sidebar's file tree is rooted at the workspace, so "show me this directory" has no tab to reach; only a regular file or a page can be opened. A folder path fails the call.
+- **A page is only as good as the composing browser tab type.** With `@qilin-agent/client-ui-sidebar-browser` composed out, the consumer falls back to a new browser tab, which leaves the application.
+- **Requests do not survive a reload.** A request made while no view was attached waits only in the Host process's memory for that Session; restarting the Host or disposing the Session drops it.
+- **The queue is bounded and drops oldest-first.** A Session whose sidebar is never shown keeps only its most recent `maxQueued` requests.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,73 @@
+---
+description: "面向模型的请求：在所属会话的侧栏中打开一个文件或一个 http(s) 页面。"
+kind: "package-reference"
+---
+
+# @qilin-agent/sidebar-opens
+
+[English](README.md) | 中文
+
+## 概述
+
+`sidebar_open` 让模型直接"展示"而不是"描述"：一个已存在的文件，或一个 http(s) 页面。请求以 Host Remote 流（`sidebarOpens.watch`）送到 [`@qilin-agent/client-ui-agent-opens`](../../client/ui-agent-opens/README.zh.md)，由它在**该会话自己的**侧栏中打开。投递是瞬时的：视图附着时随发随取，否则在每会话的有界队列里等待下一次附着重放。
+
+## 目录
+
+- [工具](#the-tool)
+- [投递](#delivery)
+- [模型体验](#model-experience)
+- [已知限制与后续工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="the-tool"></a>
+## 工具
+
+`path` 与 `url` **必须且只能提供一个**。
+
+- `path` 接受绝对路径或相对会话工作目录的路径，并在请求发出前经会话文件系统验证：无法解析、或不是普通文件时，调用本身失败，而不是打开一个坏 tab。
+- `url` 只接受 `http://` 与 `https://`。其他一律拒绝，因此模型拼出的 `file://` 到不了浏览器的打开入口。
+- 标题取文件的 basename 或页面的 host。
+
+结果报告解析后的目标，以及附着的视图是否当场取走它。Host 铸造的请求标识留在内部。
+
+<a id="delivery"></a>
+## 投递
+
+`watch(sessionId, signal)` 先产出"无人附着期间排队的请求"，再产出随后到达的每一个。同一会话的第二个 watcher 会**接管**：最新的视图就是用户正在看的那个。`enqueue` 回答附着的视图是否当场消费；无人附着时入队，并在超过 `maxQueued` 时丢弃最旧的，避免无人观看的会话无限堆积。
+
+<a id="model-experience"></a>
+## 模型体验
+
+### sidebar_open
+
+#### 模型看到什么
+
+[sidebar_open 的 schema](../../../docs/tool-catalog.zh.md#sidebar_open) 提供一个文件或一个 http(s) 页面："Open one file or one http(s) page in the Sidebar the user is viewing this Session in. Use it when the user asked to see something: a file you produced, a file worth reading beside the conversation, or a page you found. Pass exactly one of `path` (a file that already exists) or `url`. The file opens in the document preview and the page in the built-in browser; both appear beside the conversation rather than leaving the application." 结果是一行——目标已打开，或目标在等待该会话的侧栏——并带有 `kind`、`target`、`title` 与 `delivered`。
+
+#### Token 影响
+
+每次调用两个参数与一个很小的结果。这里没有任何内容进入系统提示词。
+
+#### KV Cache 影响
+
+没有直接影响。一次调用及其结果像任何工具轮次一样追加到会话；缓存随普通工具调用的方式变化。
+
+<a id="known-limitations-and-deferred-work"></a>
+## 已知限制与后续工作
+
+- **目录不可打开。** 侧栏的文件树以工作区为根，"给我看这个目录"没有可到达的 tab；只有普通文件或页面可以打开。目录路径会让调用失败。
+- **页面的落点取决于组合进来的浏览器 tab 类型。** 把 `@qilin-agent/client-ui-sidebar-browser` 组合掉时，消费者退回新浏览器标签页，即离开应用。
+- **请求不跨重新加载。** 无人附着时发出的请求只在该 Host 进程内存中等待，直到该会话结束；重启 Host 或销毁会话即丢弃。
+- **队列有界且丢弃最旧。** 从不开侧栏的会话只保留最近 `maxQueued` 个请求。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者信息 — 点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,333 @@
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import z from "@qilin-agent/schemastery";
+import { defineTool } from "@qilin-agent/tools";
+import { Remote, TypertRemoteService } from "@qilin-agent/typert-protocol";
+//#region lib/types/index.js
+/**
+* `sidebar_open`: the model-facing request to show a file or an http(s) page in
+* the Sidebar of its own Session.
+*
+* Delivery is a Host-to-browser push over a Remote stream (`watch`): a request
+* is consumed on send while a view for that Session is attached, and otherwise
+* waits in a bounded per-Session queue that a later attachment replays. A
+* request is never durable: replaying a historical open on every page load
+* would reopen a tab the user closed, which is why this is a stream and not a
+* Session event. The tool call and its result stay in the Session log like any
+* other tool, so what the model asked for is still reconstructable.
+*/
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+		else descriptor[key] = _;
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/** Stable Loader identity. */
+const name = "sidebar-opens";
+/** Services the tool verifies its target through. */
+const inject = ["tools", "fs"];
+/** Schemastery validation for {@link Config}. */
+const Config = z.object({ maxQueued: z.number().default(16) });
+/** One live watcher's inbox: pushed requests, and the wait a generator parks on. */
+var Inbox = class {
+	items = [];
+	wake;
+	closed = false;
+	/**
+	* @param request - the next request for the watcher.
+	*/
+	push(request) {
+		this.items.push(request);
+		this.wake?.();
+		this.wake = void 0;
+	}
+	/** Stop delivering: the parked wait resolves empty and later pushes are dropped. */
+	close() {
+		this.closed = true;
+		this.wake?.();
+		this.wake = void 0;
+	}
+	/**
+	* The next request, the moment one arrives.
+	*
+	* A parked wait is released by {@link close}, which a watcher's own abort
+	* handler calls, so this adds no listener of its own: one per wait would
+	* accumulate on the transport's signal for the whole life of the watch.
+	* @returns the request, or undefined once the watcher is closed.
+	*/
+	async next() {
+		while (this.items.length === 0) {
+			if (this.closed) return void 0;
+			await new Promise((resolve) => {
+				this.wake = resolve;
+			});
+		}
+		return this.items.shift();
+	}
+};
+/**
+* Per-Session open queues with their attached watchers.
+*
+* One request has one destination: with a watcher attached it is pushed there
+* and forgotten, and with none it waits in the Session's queue until a view
+* attaches. The queue is bounded because a Session nobody is watching must not
+* accumulate requests without end.
+*/
+let SidebarOpens = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _watch_decorators;
+	return class SidebarOpens extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_watch_decorators = [Remote({ mode: "stream" })];
+			__esDecorate(this, null, _watch_decorators, {
+				kind: "method",
+				name: "watch",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "watch" in obj,
+					get: (obj) => obj.watch
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		maxQueued = __runInitializers(this, _instanceExtraInitializers);
+		pending = /* @__PURE__ */ new Map();
+		watchers = /* @__PURE__ */ new Map();
+		/**
+		* @param ctx - owning Host context.
+		* @param maxQueued - requests one Session may queue while no view is attached.
+		*/
+		constructor(ctx, maxQueued) {
+			super(ctx, "sidebarOpens");
+			this.maxQueued = maxQueued;
+		}
+		/**
+		* Deliver one request to the Session's view, or queue it for the next one.
+		* @param sessionId - the Session whose Sidebar the request targets.
+		* @param request - the resolved request.
+		* @returns whether an attached view consumed it now.
+		*/
+		enqueue(sessionId, request) {
+			const watcher = this.watchers.get(sessionId);
+			if (watcher !== void 0) {
+				watcher.push(request);
+				return true;
+			}
+			const queue = this.pending.get(sessionId);
+			if (queue === void 0) {
+				this.pending.set(sessionId, [request]);
+				return false;
+			}
+			queue.push(request);
+			if (queue.length > this.maxQueued) queue.shift();
+			return false;
+		}
+		/**
+		* Watch one Session's opens: what queued while nothing was attached, then
+		* every request as it arrives.
+		* @param sessionId - the Session whose Sidebar is watching.
+		* @param signal - physical Remote stream cancellation.
+		* @returns the queued requests followed by the live ones.
+		*/
+		async *watch(sessionId, signal) {
+			const queued = this.pending.get(sessionId) ?? [];
+			this.pending.delete(sessionId);
+			const inbox = new Inbox();
+			this.watchers.get(sessionId)?.close();
+			this.watchers.set(sessionId, inbox);
+			const release = () => {
+				if (this.watchers.get(sessionId) === inbox) this.watchers.delete(sessionId);
+				inbox.close();
+			};
+			signal.addEventListener("abort", release, { once: true });
+			try {
+				for (const request of queued) {
+					if (signal.aborted) return;
+					yield request;
+				}
+				while (!signal.aborted) {
+					const request = await inbox.next();
+					if (request === void 0) return;
+					yield request;
+				}
+			} finally {
+				signal.removeEventListener("abort", release);
+				release();
+			}
+		}
+		/**
+		* Drop every queue, for a Host that is going away.
+		*/
+		dispose() {
+			this.pending.clear();
+			for (const inbox of this.watchers.values()) inbox.close();
+			this.watchers.clear();
+		}
+	};
+})();
+/** The exact http(s) URL a request may open. */
+function pageUrl(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return;
+	}
+	return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : void 0;
+}
+/**
+* Register the `sidebar_open` tool and its delivery service.
+* @param ctx - Host context with the tool registry and the filesystem.
+* @param config - validated queue bound.
+*/
+function apply(ctx, config) {
+	if (!Number.isSafeInteger(config.maxQueued) || config.maxQueued < 1) throw new Error("sidebar-opens requires a positive integer maxQueued");
+	const opens = new SidebarOpens(ctx, config.maxQueued);
+	ctx.effect(() => () => {
+		opens.dispose();
+	}, "sidebar-opens: queues");
+	ctx.tools.register(defineTool({
+		name: "sidebar_open",
+		description: "Open one file or one http(s) page in the Sidebar the user is viewing this Session in. Use it when the user asked to see something: a file you produced, a file worth reading beside the conversation, or a page you found. Pass exactly one of `path` (a file that already exists) or `url`. The file opens in the document preview and the page in the built-in browser; both appear beside the conversation rather than leaving the application.",
+		parameters: {
+			path: {
+				type: "string",
+				description: "Path of an existing regular file, relative to the Session working directory or absolute."
+			},
+			url: {
+				type: "string",
+				description: "An http:// or https:// page to open in the built-in browser."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					kind: {
+						type: "string",
+						required: true,
+						enum: ["file", "url"]
+					},
+					target: {
+						type: "string",
+						required: true
+					},
+					title: {
+						type: "string",
+						required: true
+					},
+					delivered: {
+						type: "boolean",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.delivered ? `Opened ${value.target} in the sidebar.` : `Queued ${value.target} to open in the sidebar as soon as that Session's sidebar is shown.`
+			}]
+		},
+		async execute(args, exec) {
+			if (exec.agent === void 0) throw new Error("sidebar_open requires an initiating agent");
+			const hasPath = args.path !== void 0 && args.path.trim().length > 0;
+			const hasUrl = args.url !== void 0 && args.url.trim().length > 0;
+			if (hasPath === hasUrl) throw new Error("sidebar_open requires exactly one of path or url");
+			const session = exec.agent.session;
+			const request = hasUrl ? urlRequest(args.url) : await fileRequest(ctx, exec.signal, session.header.cwd, args.path);
+			return {
+				kind: request.kind,
+				target: request.target,
+				title: request.title,
+				delivered: opens.enqueue(session.id, request)
+			};
+		}
+	}));
+}
+/**
+* One page request from the model's URL.
+* @param value - the URL as the model wrote it.
+* @returns the request to deliver.
+* @throws when the URL is malformed or is not http(s).
+*/
+function urlRequest(value) {
+	const target = pageUrl(value);
+	if (target === void 0) throw new Error("sidebar_open only opens http:// and https:// URLs; pass a path for a local file");
+	return {
+		id: randomUUID(),
+		kind: "url",
+		target,
+		title: new URL(target).host
+	};
+}
+/**
+* One file request, verified through the Session filesystem before it is made
+* so the browser never opens a path that does not resolve.
+* @param ctx - Host context carrying the filesystem.
+* @param signal - tool cancellation.
+* @param cwd - the Session working directory relative paths resolve against.
+* @param value - the path as the model wrote it.
+* @returns the request to deliver.
+* @throws when the path does not name a regular file.
+*/
+async function fileRequest(ctx, signal, cwd, value) {
+	signal.throwIfAborted();
+	const target = await ctx.fs.resolve(value, {
+		...cwd === void 0 ? {} : { cwd },
+		signal
+	});
+	const info = await ctx.fs.stat(target, signal);
+	if (info === void 0) throw new Error(`Cannot open ${value}: file not found. Check the path and retry.`);
+	if (info.type !== "file") throw new Error(`Cannot open ${value}: not a regular file`);
+	signal.throwIfAborted();
+	const path = ctx.fs.processPath(target);
+	return {
+		id: randomUUID(),
+		kind: "file",
+		target: path,
+		title: basename(path)
+	};
+}
+//#endregion
+export { Config, SidebarOpens, apply, inject, name };

package/lib/typert.host.d.ts

@@ -0,0 +1,3 @@
+/* Generated by @qilin-agent/typert-generator from FaceModel — do not edit. */
+
+export declare const TYPERT: unknown

package/lib/typert.host.js

@@ -0,0 +1,99 @@
+/* Generated by @qilin-agent/typert-generator from FaceModel — do not edit. */
+import { z } from 'zod'
+
+let _qilin_agent_sidebar_opens_sidebarOpens_watch_parameter_0$schema$value
+const _qilin_agent_sidebar_opens_sidebarOpens_watch_parameter_0$schema = () => (_qilin_agent_sidebar_opens_sidebarOpens_watch_parameter_0$schema$value ??= z.intersection(z.string(), z.unknown()))
+let _qilin_agent_sidebar_opens_sidebarOpens_watch_result$schema$value
+const _qilin_agent_sidebar_opens_sidebarOpens_watch_result$schema = () => (_qilin_agent_sidebar_opens_sidebarOpens_watch_result$schema$value ??= z.object({
+  'id': z.string().readonly(),
+  'kind': z.union([z.literal("file"), z.literal("url")]).readonly(),
+  'target': z.string().readonly(),
+  'title': z.string().readonly(),
+}))
+
+export const TYPERT = {
+  package: '@qilin-agent/sidebar-opens',
+  face: 'host',
+  schemas: [
+  ],
+  invocations: [
+    {
+      id: '@qilin-agent/sidebar-opens#sidebarOpens/watch',
+      service: 'sidebarOpens',
+      namespace: 'sidebarOpens',
+      method: 'watch',
+      mode: 'stream',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'sessionId',
+          wire: 'sessionId',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@qilin-agent/session/types#SessionId',
+            create: _qilin_agent_sidebar_opens_sidebarOpens_watch_parameter_0$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@qilin-agent/sidebar-opens/types#SidebarOpenRequest',
+        create: _qilin_agent_sidebar_opens_sidebarOpens_watch_result$schema,
+      },
+      sourceLocation: {"file":"packages/host/sidebar-opens/src/index.ts","line":143,"column":10},
+    },
+  ],
+  model: {
+    "services": [
+      {
+        "description": "Per-Session open queues with their attached watchers. One request has one destination: with a watcher attached it is pushed there and forgotten, and with none it waits in the Session's queue until a view attaches. The queue is bounded because a Session nobody is watching must not accumulate requests without end.",
+        "summary": "Per-Session open queues with their attached watchers.",
+        "tags": [],
+        "jsDoc": "/**\n * Per-Session open queues with their attached watchers.\n *\n * One request has one destination: with a watcher attached it is pushed there\n * and forgotten, and with none it waits in the Session's queue until a view\n * attaches. The queue is bounded because a Session nobody is watching must not\n * accumulate requests without end.\n */",
+        "key": "sidebarOpens",
+        "exportName": "SidebarOpens",
+        "members": [
+          {
+            "kind": "method",
+            "name": "enqueue",
+            "signature": "enqueue(sessionId: SessionId, request: SidebarOpenRequest): boolean",
+            "summary": "Deliver one request to the Session's view, or queue it for the next one.",
+            "jsDoc": "/**\n * Deliver one request to the Session's view, or queue it for the next one.\n * @param sessionId - the Session whose Sidebar the request targets.\n * @param request - the resolved request.\n * @returns whether an attached view consumed it now.\n */"
+          },
+          {
+            "kind": "method",
+            "name": "watch",
+            "signature": "@Remote({ mode: 'stream' }) async *watch(sessionId: SessionId, signal: AbortSignal): AsyncIterable<SidebarOpenRequest>",
+            "summary": "Watch one Session's opens: what queued while nothing was attached, then every request as it arrives.",
+            "jsDoc": "/**\n * Watch one Session's opens: what queued while nothing was attached, then\n * every request as it arrives.\n * @param sessionId - the Session whose Sidebar is watching.\n * @param signal - physical Remote stream cancellation.\n * @returns the queued requests followed by the live ones.\n */"
+          },
+          {
+            "kind": "method",
+            "name": "dispose",
+            "signature": "dispose(): void",
+            "summary": "Drop every queue, for a Host that is going away.",
+            "jsDoc": "/**\n * Drop every queue, for a Host that is going away.\n */"
+          }
+        ],
+        "types": [
+          {
+            "name": "Branded",
+            "declaration": "export type Branded<B extends string> = string & { readonly [BRAND]: B; };"
+          },
+          {
+            "name": "SessionId",
+            "declaration": "export type SessionId = Branded<'SessionId'>;"
+          },
+          {
+            "name": "SidebarOpenRequest",
+            "declaration": "export interface SidebarOpenRequest {\n    readonly id: string;\n    readonly kind: 'file' | 'url';\n    readonly target: string;\n    readonly title: string;\n}"
+          }
+        ]
+      }
+    ],
+    "events": [],
+    "objects": []
+  },
+}

package/lib/typert.remote-client.d.ts

@@ -0,0 +1,24 @@
+/* Generated by @qilin-agent/typert-generator from the Host FaceModel — do not edit. */
+import type {
+  RemoteResult,
+  RemoteStreamHandle,
+  TypertRemoteContribution,
+} from '@qilin-agent/typert-protocol'
+import type { SessionId } from '@qilin-agent/session/types'
+import type { SidebarOpenRequest } from '@qilin-agent/sidebar-opens/types'
+
+declare module '@qilin-agent/typert-protocol' {
+  interface TypertRemoteNamespace$736964656261724f70656e73 {
+    watch: (sessionId: SessionId, signal?: AbortSignal) => RemoteStreamHandle<SidebarOpenRequest, never>
+  }
+  interface TypertRemoteMap {
+    'sidebarOpens/watch': (sessionId: SessionId, signal?: AbortSignal) => RemoteStreamHandle<SidebarOpenRequest, never>
+  }
+  interface TypertRemoteNamespaceMap {
+    'sidebarOpens': TypertRemoteNamespace$736964656261724f70656e73
+  }
+}
+
+export declare const TYPERT_REMOTE: TypertRemoteContribution
+export default TYPERT_REMOTE
+//# sourceMappingURL=typert.remote-client.d.ts.map

package/lib/typert.remote-client.js

@@ -0,0 +1,47 @@
+/* Generated by @qilin-agent/typert-generator from the Host FaceModel — do not edit. */
+import { z } from 'zod'
+
+let _qilin_agent_sidebar_opens_sidebarOpens_watch_parameter_0$schema$value
+const _qilin_agent_sidebar_opens_sidebarOpens_watch_parameter_0$schema = () => (_qilin_agent_sidebar_opens_sidebarOpens_watch_parameter_0$schema$value ??= z.intersection(z.string(), z.unknown()))
+let _qilin_agent_sidebar_opens_sidebarOpens_watch_result$schema$value
+const _qilin_agent_sidebar_opens_sidebarOpens_watch_result$schema = () => (_qilin_agent_sidebar_opens_sidebarOpens_watch_result$schema$value ??= z.object({
+  'id': z.string().readonly(),
+  'kind': z.union([z.literal("file"), z.literal("url")]).readonly(),
+  'target': z.string().readonly(),
+  'title': z.string().readonly(),
+}))
+
+export const TYPERT_REMOTE = {
+  package: '@qilin-agent/sidebar-opens',
+  descriptors: [
+    {
+      id: '@qilin-agent/sidebar-opens#sidebarOpens/watch',
+      service: 'sidebarOpens',
+      namespace: 'sidebarOpens',
+      method: 'watch',
+      mode: 'stream',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'sessionId',
+          wire: 'sessionId',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@qilin-agent/session/types#SessionId',
+            create: _qilin_agent_sidebar_opens_sidebarOpens_watch_parameter_0$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@qilin-agent/sidebar-opens/types#SidebarOpenRequest',
+        create: _qilin_agent_sidebar_opens_sidebarOpens_watch_result$schema,
+      },
+      sourceLocation: {"file":"packages/host/sidebar-opens/src/index.ts","line":143,"column":10},
+    },
+  ],
+}
+
+export default TYPERT_REMOTE

package/lib/types/index.d.ts

@@ -0,0 +1,67 @@
+import type { Context } from '@qilin-agent/kylin';
+import z from '@qilin-agent/schemastery';
+import type { SessionId } from '@qilin-agent/session';
+import { TypertRemoteService } from '@qilin-agent/typert-protocol';
+import type { SidebarOpenRequest } from './types.ts';
+export type * from './types.ts';
+/** Stable Loader identity. */
+export declare const name = "sidebar-opens";
+/** Services the tool verifies its target through. */
+export declare const inject: string[];
+declare module '@qilin-agent/kylin' {
+    interface Context {
+        /** Pending and live sidebar opens, one bounded queue per Session. */
+        sidebarOpens: SidebarOpens;
+    }
+}
+/** Deployment limits for the pending queue. */
+export interface Config {
+    /** Open requests a Session may queue while no Sidebar view is attached. */
+    readonly maxQueued: number;
+}
+/** Schemastery validation for {@link Config}. */
+export declare const Config: z<Config>;
+/**
+ * Per-Session open queues with their attached watchers.
+ *
+ * One request has one destination: with a watcher attached it is pushed there
+ * and forgotten, and with none it waits in the Session's queue until a view
+ * attaches. The queue is bounded because a Session nobody is watching must not
+ * accumulate requests without end.
+ */
+export declare class SidebarOpens extends TypertRemoteService {
+    private readonly maxQueued;
+    private readonly pending;
+    private readonly watchers;
+    /**
+     * @param ctx - owning Host context.
+     * @param maxQueued - requests one Session may queue while no view is attached.
+     */
+    constructor(ctx: Context, maxQueued: number);
+    /**
+     * Deliver one request to the Session's view, or queue it for the next one.
+     * @param sessionId - the Session whose Sidebar the request targets.
+     * @param request - the resolved request.
+     * @returns whether an attached view consumed it now.
+     */
+    enqueue(sessionId: SessionId, request: SidebarOpenRequest): boolean;
+    /**
+     * Watch one Session's opens: what queued while nothing was attached, then
+     * every request as it arrives.
+     * @param sessionId - the Session whose Sidebar is watching.
+     * @param signal - physical Remote stream cancellation.
+     * @returns the queued requests followed by the live ones.
+     */
+    watch(sessionId: SessionId, signal: AbortSignal): AsyncIterable<SidebarOpenRequest>;
+    /**
+     * Drop every queue, for a Host that is going away.
+     */
+    dispose(): void;
+}
+/**
+ * Register the `sidebar_open` tool and its delivery service.
+ * @param ctx - Host context with the tool registry and the filesystem.
+ * @param config - validated queue bound.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,313 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+/**
+ * `sidebar_open`: the model-facing request to show a file or an http(s) page in
+ * the Sidebar of its own Session.
+ *
+ * Delivery is a Host-to-browser push over a Remote stream (`watch`): a request
+ * is consumed on send while a view for that Session is attached, and otherwise
+ * waits in a bounded per-Session queue that a later attachment replays. A
+ * request is never durable: replaying a historical open on every page load
+ * would reopen a tab the user closed, which is why this is a stream and not a
+ * Session event. The tool call and its result stay in the Session log like any
+ * other tool, so what the model asked for is still reconstructable.
+ */
+import { randomUUID } from 'node:crypto';
+import { basename } from 'node:path';
+import z from '@qilin-agent/schemastery';
+import { defineTool } from '@qilin-agent/tools';
+import { Remote, TypertRemoteService } from '@qilin-agent/typert-protocol';
+/** Stable Loader identity. */
+export const name = 'sidebar-opens';
+/** Services the tool verifies its target through. */
+export const inject = ['tools', 'fs'];
+/** Schemastery validation for {@link Config}. */
+export const Config = z.object({
+    maxQueued: z.number().default(16),
+});
+/** One live watcher's inbox: pushed requests, and the wait a generator parks on. */
+class Inbox {
+    items = [];
+    wake;
+    closed = false;
+    /**
+     * @param request - the next request for the watcher.
+     */
+    push(request) {
+        this.items.push(request);
+        this.wake?.();
+        this.wake = undefined;
+    }
+    /** Stop delivering: the parked wait resolves empty and later pushes are dropped. */
+    close() {
+        this.closed = true;
+        this.wake?.();
+        this.wake = undefined;
+    }
+    /**
+     * The next request, the moment one arrives.
+     *
+     * A parked wait is released by {@link close}, which a watcher's own abort
+     * handler calls, so this adds no listener of its own: one per wait would
+     * accumulate on the transport's signal for the whole life of the watch.
+     * @returns the request, or undefined once the watcher is closed.
+     */
+    async next() {
+        while (this.items.length === 0) {
+            if (this.closed)
+                return undefined;
+            await new Promise((resolve) => {
+                this.wake = resolve;
+            });
+        }
+        return this.items.shift();
+    }
+}
+/**
+ * Per-Session open queues with their attached watchers.
+ *
+ * One request has one destination: with a watcher attached it is pushed there
+ * and forgotten, and with none it waits in the Session's queue until a view
+ * attaches. The queue is bounded because a Session nobody is watching must not
+ * accumulate requests without end.
+ */
+let SidebarOpens = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _watch_decorators;
+    return class SidebarOpens extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _watch_decorators = [Remote({ mode: 'stream' })];
+            __esDecorate(this, null, _watch_decorators, { kind: "method", name: "watch", static: false, private: false, access: { has: obj => "watch" in obj, get: obj => obj.watch }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        maxQueued = __runInitializers(this, _instanceExtraInitializers);
+        pending = new Map();
+        watchers = new Map();
+        /**
+         * @param ctx - owning Host context.
+         * @param maxQueued - requests one Session may queue while no view is attached.
+         */
+        constructor(ctx, maxQueued) {
+            super(ctx, 'sidebarOpens');
+            this.maxQueued = maxQueued;
+        }
+        /**
+         * Deliver one request to the Session's view, or queue it for the next one.
+         * @param sessionId - the Session whose Sidebar the request targets.
+         * @param request - the resolved request.
+         * @returns whether an attached view consumed it now.
+         */
+        enqueue(sessionId, request) {
+            const watcher = this.watchers.get(sessionId);
+            if (watcher !== undefined) {
+                watcher.push(request);
+                return true;
+            }
+            const queue = this.pending.get(sessionId);
+            if (queue === undefined) {
+                this.pending.set(sessionId, [request]);
+                return false;
+            }
+            queue.push(request);
+            // The oldest request is the one a stalled viewer has already been told
+            // about least often; drop it rather than grow without bound.
+            if (queue.length > this.maxQueued)
+                queue.shift();
+            return false;
+        }
+        /**
+         * Watch one Session's opens: what queued while nothing was attached, then
+         * every request as it arrives.
+         * @param sessionId - the Session whose Sidebar is watching.
+         * @param signal - physical Remote stream cancellation.
+         * @returns the queued requests followed by the live ones.
+         */
+        async *watch(sessionId, signal) {
+            const queued = this.pending.get(sessionId) ?? [];
+            this.pending.delete(sessionId);
+            const inbox = new Inbox();
+            // A second view for the same Session takes over: the newest watcher is the
+            // one the user is looking at.
+            this.watchers.get(sessionId)?.close();
+            this.watchers.set(sessionId, inbox);
+            const release = () => {
+                if (this.watchers.get(sessionId) === inbox)
+                    this.watchers.delete(sessionId);
+                inbox.close();
+            };
+            signal.addEventListener('abort', release, { once: true });
+            try {
+                for (const request of queued) {
+                    if (signal.aborted)
+                        return;
+                    yield request;
+                }
+                while (!signal.aborted) {
+                    const request = await inbox.next();
+                    if (request === undefined)
+                        return;
+                    yield request;
+                }
+            }
+            finally {
+                signal.removeEventListener('abort', release);
+                release();
+            }
+        }
+        /**
+         * Drop every queue, for a Host that is going away.
+         */
+        dispose() {
+            this.pending.clear();
+            for (const inbox of this.watchers.values())
+                inbox.close();
+            this.watchers.clear();
+        }
+    };
+})();
+export { SidebarOpens };
+/** The exact http(s) URL a request may open. */
+function pageUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return undefined;
+    }
+    return url.protocol === 'http:' || url.protocol === 'https:' ? url.toString() : undefined;
+}
+/**
+ * Register the `sidebar_open` tool and its delivery service.
+ * @param ctx - Host context with the tool registry and the filesystem.
+ * @param config - validated queue bound.
+ */
+export function apply(ctx, config) {
+    if (!Number.isSafeInteger(config.maxQueued) || config.maxQueued < 1) {
+        throw new Error('sidebar-opens requires a positive integer maxQueued');
+    }
+    const opens = new SidebarOpens(ctx, config.maxQueued);
+    ctx.effect(() => () => { opens.dispose(); }, 'sidebar-opens: queues');
+    ctx.tools.register(defineTool({
+        name: 'sidebar_open',
+        description: 'Open one file or one http(s) page in the Sidebar the user is viewing this Session in. '
+            + 'Use it when the user asked to see something: a file you produced, a file worth reading beside the conversation, '
+            + 'or a page you found. Pass exactly one of `path` (a file that already exists) or `url`. '
+            + 'The file opens in the document preview and the page in the built-in browser; both appear beside the conversation '
+            + 'rather than leaving the application.',
+        parameters: {
+            path: {
+                type: 'string',
+                description: 'Path of an existing regular file, relative to the Session working directory or absolute.',
+            },
+            url: {
+                type: 'string',
+                description: 'An http:// or https:// page to open in the built-in browser.',
+            },
+        },
+        output: {
+            schema: {
+                type: 'object', additionalProperties: false,
+                properties: {
+                    kind: { type: 'string', required: true, enum: ['file', 'url'] },
+                    target: { type: 'string', required: true },
+                    title: { type: 'string', required: true },
+                    delivered: { type: 'boolean', required: true },
+                },
+            },
+            render: (_args, value) => [{
+                    type: 'text',
+                    text: value.delivered
+                        ? `Opened ${value.target} in the sidebar.`
+                        : `Queued ${value.target} to open in the sidebar as soon as that Session's sidebar is shown.`,
+                }],
+        },
+        async execute(args, exec) {
+            if (exec.agent === undefined)
+                throw new Error('sidebar_open requires an initiating agent');
+            const hasPath = args.path !== undefined && args.path.trim().length > 0;
+            const hasUrl = args.url !== undefined && args.url.trim().length > 0;
+            if (hasPath === hasUrl)
+                throw new Error('sidebar_open requires exactly one of path or url');
+            const session = exec.agent.session;
+            const request = hasUrl
+                ? urlRequest(args.url)
+                : await fileRequest(ctx, exec.signal, session.header.cwd, args.path);
+            // The host-minted identity stays internal: the model is told what it
+            // asked for, not how the browser will dedupe it.
+            return {
+                kind: request.kind, target: request.target, title: request.title,
+                delivered: opens.enqueue(session.id, request),
+            };
+        },
+    }));
+}
+/**
+ * One page request from the model's URL.
+ * @param value - the URL as the model wrote it.
+ * @returns the request to deliver.
+ * @throws when the URL is malformed or is not http(s).
+ */
+function urlRequest(value) {
+    const target = pageUrl(value);
+    if (target === undefined)
+        throw new Error('sidebar_open only opens http:// and https:// URLs; pass a path for a local file');
+    return { id: randomUUID(), kind: 'url', target, title: new URL(target).host };
+}
+/**
+ * One file request, verified through the Session filesystem before it is made
+ * so the browser never opens a path that does not resolve.
+ * @param ctx - Host context carrying the filesystem.
+ * @param signal - tool cancellation.
+ * @param cwd - the Session working directory relative paths resolve against.
+ * @param value - the path as the model wrote it.
+ * @returns the request to deliver.
+ * @throws when the path does not name a regular file.
+ */
+async function fileRequest(ctx, signal, cwd, value) {
+    signal.throwIfAborted();
+    const target = await ctx.fs.resolve(value, { ...cwd === undefined ? {} : { cwd }, signal });
+    const info = await ctx.fs.stat(target, signal);
+    if (info === undefined)
+        throw new Error(`Cannot open ${value}: file not found. Check the path and retry.`);
+    if (info.type !== 'file')
+        throw new Error(`Cannot open ${value}: not a regular file`);
+    signal.throwIfAborted();
+    const path = ctx.fs.processPath(target);
+    return { id: randomUUID(), kind: 'file', target: path, title: basename(path) };
+}
+//# sourceMappingURL=index.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,17 @@
+/** What the model asked the sidebar to show, and how one request reaches the browser. */
+/** One open request, as the tool resolved it. */
+export interface SidebarOpenRequest {
+    /** Host-minted identity, so a client can dedupe a replay it already applied. */
+    readonly id: string;
+    /** What the target is. */
+    readonly kind: 'file' | 'url';
+    /**
+     * The absolute Host path of the file, or the normalized http(s) URL of the
+     * page. A file path is verified to be a regular file before the request is
+     * made; a URL is verified to be http(s).
+     */
+    readonly target: string;
+    /** The tab title to use: the file's basename, or the page's host. */
+    readonly title: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,3 @@
+/** What the model asked the sidebar to show, and how one request reaches the browser. */
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,74 @@
 {
   "name": "@qilin-agent/sidebar-opens",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Model-facing requests to open a file or an http(s) page in the Session's Sidebar",
+  "version": "3.1.4",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkutysllb/QiLin.git",
+    "directory": "packages/host/sidebar-opens"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./typert": {
+      "types": "./lib/typert.host.d.ts",
+      "default": "./lib/typert.host.js"
+    },
+    "./remote": {
+      "types": "./lib/typert.remote-client.d.ts",
+      "default": "./lib/typert.remote-client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts",
+    "lib/typert.host.js",
+    "lib/typert.host.d.ts",
+    "lib/typert.remote-client.js",
+    "lib/typert.remote-client.d.ts"
+  ],
+  "dependencies": {
+    "zod": "^4.4.3",
+    "@qilin-agent/schemastery": "~3.18.3"
+  },
+  "peerDependencies": {
+    "@qilin-agent/agent": "3.1.4",
+    "@qilin-agent/fs": "3.1.4",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/session": "3.1.4",
+    "@qilin-agent/typert-protocol": "3.1.4",
+    "@qilin-agent/tools": "3.1.4"
+  },
+  "devDependencies": {
+    "@qilin-agent/agent": "3.1.4",
+    "@qilin-agent/agent-loop-testkit": "3.1.4",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/fs": "3.1.4",
+    "@qilin-agent/fs-local": "3.1.4",
+    "@qilin-agent/llm": "3.1.4",
+    "@qilin-agent/scope": "3.1.4",
+    "@qilin-agent/session": "3.1.4",
+    "@qilin-agent/typert-protocol": "3.1.4",
+    "@qilin-agent/tools": "3.1.4",
+    "@qilin-agent/system-prompt": "3.1.4"
+  }
 }