@skydiveai/pi-extensions 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Create, Inc.
+
+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.md

@@ -0,0 +1,28 @@
+# @skydiveai/pi-extensions
+
+pi extensions for agent-owned content plus the Skydive platform layer.
+
+Extensions (load agent workspace content):
+
+- `soulExtension` — soul.md personality
+- `memoryExtension` — .memory/ markdown index
+- `mcpExtension` — mcp.config.json servers, with hot reload and OAuth
+- `localToolsExtension` — tools/\*.ts custom tools, with hot reload
+- `toolCallEnvExtension` — TOOL_CALL_ID env for bash tools
+- `all` — the stock set in load order
+- `platformExtensions({ sessionId, channelContext })` — Skydive-owned:
+  daemon session tracking, sandbox heartbeats, OTel self-tracing. Every
+  session must include these.
+
+Platform layer:
+
+- `createHarness` — composes @skydiveai/pi-server's protocol handlers
+  with the Skydive defaults (daemon-exported tracing, tool-update
+  hot-reload hooks, prewarm paths, proxy header passthrough, agent-card
+  branding) into mountable express handlers
+- `createPlatformEnvMiddleware` / `createHealthHandler` — env injection
+  from the in-sandbox daemon / e2b envd, and the platform health payload
+
+Published to the private Verdaccio registry by the deploy pipeline's
+`publish-system-artifacts` job; the agent harness workspace consumes both
+packages as regular npm dependencies.

package/dist/index.d.mts

@@ -0,0 +1,163 @@
+/// <reference types="node" />
+import { A2AOptions, Middleware, ProtocolsOptions } from "@skydiveai/pi-server";
+import { ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import * as _$qs from "qs";
+import * as _$express from "express";
+import { Logger } from "pino";
+
+//#region ../../node_modules/@types/express-serve-static-core/index.d.ts
+declare global {
+  namespace Express {
+    // These open interfaces may be extended in an application-specific manner via declaration merging.
+    // See for example method-override.d.ts (https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/method-override/index.d.ts)
+    interface Request {}
+    interface Response {}
+    interface Locals {}
+    interface Application {}
+  }
+}
+interface ParamsDictionary {
+  [key: string]: string;
+}
+//#endregion
+//#region src/harness.d.ts
+type CreateHarnessOptions = ProtocolsOptions & {
+  cwd: string;
+  agentCard?: A2AOptions['agentCard']; /** Merged into the GET /health payload as `metadata`. */
+  healthMetadata?: () => Record<string, unknown>;
+};
+declare function createHarness(options: CreateHarnessOptions): {
+  platform: {
+    handlers: {
+      /**
+       * Platform health plus the agent's `healthMetadata`. Mount above
+       * injectEnv — health must respond immediately for prewarm
+       * stashing and readiness probes, and injectEnv can wait up to
+       * 10s for env vars during boot.
+       */
+      health: Middleware; /** Loads platform env (e2b envd / daemon long-poll). */
+      injectEnv: Middleware;
+      prewarm: Middleware;
+    };
+  };
+  protocols: {
+    handlers: {
+      /** Express-style; mount at /a2a. */a2a: _$express.RequestHandler<ParamsDictionary, any, any, _$qs.ParsedQs, Record<string, any>>; /** GET /.well-known/agent-card.json. */
+      agentCard: Middleware; /** Mirrors each vendor's API shape. */
+      openai: {
+        v1: {
+          chat: {
+            completions: Middleware;
+          };
+          responses: Middleware;
+        };
+      };
+      anthropic: {
+        v1: {
+          messages: Middleware;
+        };
+      };
+      /**
+       * Everything in one mount: a2a (+ agent card) at their well-known
+       * paths, then chat-completions / anthropic-messages / responses.
+       * Calls next() when nothing matches.
+       */
+      all: Middleware;
+    };
+  };
+};
+//#endregion
+//#region src/platform-middleware.d.ts
+/**
+ * Middleware that loads platform config (e2b envd / daemon env) before
+ * requests reach the protocol handlers. Builds a headers-only Request —
+ * the body stream must stay untouched for the downstream handlers.
+ * Mount above everything except /health; it can wait up to 10s for env
+ * vars during boot.
+ */
+declare function createPlatformEnvMiddleware(): Middleware;
+/**
+ * GET /health handler: platform health data plus whatever the agent's
+ * `metadata` callback returns. Must respond immediately (readiness
+ * probes, prewarm stashing) — mount it above the platform env
+ * middleware.
+ */
+declare function createHealthHandler({
+  metadata
+}: {
+  metadata: (() => Record<string, unknown>) | null;
+}): Middleware;
+//#endregion
+//#region src/platform-env-middleware.d.ts
+declare function isPlatformConfigLoaded(): boolean;
+declare function loadPlatformConfig(request: Request): Promise<void>;
+//#endregion
+//#region src/extensions/local-tools.d.ts
+declare const localToolsExtension: ExtensionFactory;
+//#endregion
+//#region src/extensions/mcp/index.d.ts
+declare const _default: ExtensionFactory;
+//#endregion
+//#region src/extensions/memory.d.ts
+declare const memoryExtension: ExtensionFactory;
+//#endregion
+//#region src/extensions/soul.d.ts
+declare const soulExtension: ExtensionFactory;
+//#endregion
+//#region src/extensions/tool-call-env.d.ts
+declare const toolCallEnvExtension: ExtensionFactory;
+//#endregion
+//#region src/extensions/index.d.ts
+/**
+ * The static (config-free) agent extensions, in load order. `memoryExtension`
+ * is the generic, agent-owned slice (`projects/`/`feedback/`/`reference/`); the
+ * per-user `users/` slice is rendered by the platform memory extension inside
+ * `platformExtensions()`, which can resolve the current user.
+ */
+declare const all: ExtensionFactory[];
+/**
+ * Platform-owned extensions — daemon session tracking, sandbox heartbeats,
+ * OTel self-tracing, and background tasks. These are platform capabilities
+ * every session must include (not agent-authored content); the session
+ * factory appends them to the agent-chosen set.
+ */
+declare function platformExtensions({
+  sessionId,
+  channelContext
+}: {
+  sessionId: string;
+  channelContext: string | null;
+}): ExtensionFactory[];
+//#endregion
+//#region src/tool-update-loop.d.ts
+type SessionLike = {
+  reload: () => Promise<void>;
+  bindExtensions: (vars: Record<string, unknown>) => Promise<void>;
+  sendCustomMessage: (msg: {
+    customType: string;
+    content: string;
+    display: boolean;
+    details: Record<string, unknown>;
+  }, options: {
+    triggerTurn: boolean;
+  }) => Promise<void>;
+};
+type SessionWithAgent = {
+  agent: unknown;
+} & SessionLike;
+declare function installToolUpdateAutoStop({
+  session,
+  log
+}: {
+  session: SessionWithAgent;
+  log: Logger;
+}): void;
+declare function runToolUpdateLoop({
+  session,
+  log
+}: {
+  session: SessionLike;
+  log: Logger;
+}): Promise<void>;
+//#endregion
+export { type CreateHarnessOptions, all, createHarness, createHealthHandler, createPlatformEnvMiddleware, installToolUpdateAutoStop, isPlatformConfigLoaded, loadPlatformConfig, localToolsExtension, _default as mcpExtension, memoryExtension, platformExtensions, runToolUpdateLoop, soulExtension, toolCallEnvExtension };