agentengine-sdk-python 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

ksadk/plugins/providers/bundles/ksadk-dsh-capability-host/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@kingsoftcloud/ksadk-dsh-capability-host",
+  "version": "1.0.0",
+  "description": "Profile-level Cordis tools to authenticated Streamable HTTP MCP bridge",
+  "type": "module",
+  "exports": {
+    ".": "./index.mjs",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "index.mjs",
+    "cordis.patch.yml"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-tools": "0.1.5-rc.1"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml",
+      "integrity": "sha256:c69f9d358c0aa4d16d91f39170b0ae42069a5c173d19924fe75d64c6f91e40c8"
+    }
+  }
+}

ksadk/plugins/providers/bundles/ksadk-dsh-companion-host/client.mjs

@@ -0,0 +1,133 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { randomUUID } from 'node:crypto'
+import { createConnection } from 'node:net'
+
+const MAX_BYTES = 1024 * 1024
+export class CompanionBridgeError extends Error {
+  constructor(code) { super(code); this.code = code }
+}
+const fail = code => new CompanionBridgeError(code)
+
+export class CompanionBridge {
+  #configuration
+  #context = new AsyncLocalStorage()
+  #tools = new Map()
+  #sockets = new Set()
+  #closed = false
+
+  constructor(config) {
+    if (!config || typeof config.socketPath !== 'string' || !config.socketPath.startsWith('/') ||
+        typeof config.secret !== 'string' || typeof config.generationId !== 'string') {
+      throw fail('COMPANION_CONFIGURATION_INVALID')
+    }
+    this.#configuration = config
+  }
+  get generationId() { return this.#configuration.generationId }
+  operationForTool(name) { return this.#tools.get(name) }
+
+  async registerComponent(pluginId, component) {
+    if (!this.#configuration.plugins?.[pluginId]?.components.includes(component)) {
+      throw fail('COMPANION_COMPONENT_INVALID')
+    }
+    const socket = await this.#request({
+      type: 'register', pluginId, component,
+      generationId: this.generationId, secret: this.#configuration.secret,
+    }, { keepOpen: true, deadline: Date.now() + 5000 })
+    return () => { this.#sockets.delete(socket); socket.destroy() }
+  }
+
+  registerTool(name, pluginId, operation) {
+    if (this.#tools.has(name) || !this.#configuration.plugins?.[pluginId]) {
+      throw fail('COMPANION_TOOL_INVALID')
+    }
+    const entry = Object.freeze({ pluginId, operation })
+    this.#tools.set(name, entry)
+    return () => { if (this.#tools.get(name) === entry) this.#tools.delete(name) }
+  }
+
+  withInvocation(context, callback) {
+    if (!context || context.generationId !== this.generationId ||
+        !/^[A-Za-z0-9_-]{32,256}$/.test(context.handle) ||
+        typeof context.callId !== 'string' || !context.callId || context.callId.length > 128 ||
+        !Number.isSafeInteger(context.deadline) || context.deadline <= Date.now()) {
+      throw fail('COMPANION_CONTEXT_REQUIRED')
+    }
+    return this.#context.run(Object.freeze({ ...context }), callback)
+  }
+
+  call(toolName, args, { signal } = {}) {
+    const context = this.#context.getStore()
+    const operation = this.#tools.get(toolName)
+    if (!context || !operation || operation.pluginId !== context.pluginId) {
+      throw fail('COMPANION_CONTEXT_REQUIRED')
+    }
+    const signals = [context.signal, signal].filter(Boolean)
+    return this.#request({
+      type: 'invoke', pluginId: operation.pluginId, operation: operation.operation,
+      handle: context.handle, callId: context.callId, arguments: args,
+      deadline: context.deadline,
+    }, { deadline: context.deadline, signal: signals.length ? AbortSignal.any(signals) : undefined })
+  }
+
+  #request(request, { keepOpen = false, deadline, signal }) {
+    if (this.#closed) throw fail('COMPANION_CLOSED')
+    if (this.#sockets.size >= 96) throw fail('COMPANION_BUSY')
+    const requestId = randomUUID()
+    const body = Buffer.from(JSON.stringify({ v: 1, requestId, ...request }))
+    if (body.length > MAX_BYTES) throw fail('COMPANION_REQUEST_INVALID')
+    const prefix = Buffer.alloc(4)
+    prefix.writeUInt32BE(body.length)
+    return new Promise((resolve, reject) => {
+      const socket = createConnection({ path: this.#configuration.socketPath })
+      this.#sockets.add(socket)
+      let received = Buffer.alloc(0), expected, settled = false
+      const finish = (error, result) => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        signal?.removeEventListener('abort', abort)
+        if (!keepOpen || error) { this.#sockets.delete(socket); socket.destroy() }
+        if (error) reject(error); else resolve(keepOpen ? socket : result)
+      }
+      const abort = () => finish(fail('COMPANION_CANCELLED'))
+      const timer = setTimeout(() => finish(fail('COMPANION_OUTCOME_UNCERTAIN')), Math.max(1, deadline - Date.now()))
+      if (signal?.aborted) { abort(); return }
+      signal?.addEventListener('abort', abort, { once: true })
+      socket.once('connect', () => socket.write(Buffer.concat([prefix, body])))
+      socket.on('error', () => finish(fail('COMPANION_OUTCOME_UNCERTAIN')))
+      socket.once('close', () => {
+        this.#sockets.delete(socket)
+        finish(fail('COMPANION_OUTCOME_UNCERTAIN'))
+      })
+      socket.on('data', chunk => {
+        if (settled) return
+        if (received.length + chunk.length > MAX_BYTES + 4) return finish(fail('COMPANION_RESPONSE_INVALID'))
+        received = Buffer.concat([received, chunk])
+        if (expected === undefined && received.length >= 4) {
+          expected = received.readUInt32BE(0)
+          if (!expected || expected > MAX_BYTES) return finish(fail('COMPANION_RESPONSE_INVALID'))
+        }
+        if (expected === undefined || received.length < expected + 4) return
+        if (received.length !== expected + 4) return finish(fail('COMPANION_RESPONSE_INVALID'))
+        try {
+          const response = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(received.subarray(4)))
+          if (response?.v !== 1 || response.requestId !== requestId) throw fail('COMPANION_RESPONSE_INVALID')
+          if (response.error) throw fail(/^COMPANION_[A-Z_]+$/.test(response.error.code)
+            ? response.error.code : 'COMPANION_RESPONSE_INVALID')
+          if (!response.result || typeof response.result !== 'object' || Array.isArray(response.result)) {
+            throw fail('COMPANION_RESPONSE_INVALID')
+          }
+          finish(null, response.result)
+        } catch (error) { finish(error instanceof CompanionBridgeError ? error : fail('COMPANION_RESPONSE_INVALID')) }
+      })
+    })
+  }
+
+  dispose() {
+    this.#closed = true
+    for (const socket of this.#sockets) socket.destroy()
+    this.#sockets.clear()
+    this.#tools.clear()
+    this.#context.disable()
+  }
+}

ksadk/plugins/providers/bundles/ksadk-dsh-companion-host/index.mjs

@@ -0,0 +1,14 @@
+import { CompanionBridge } from './client.mjs'
+
+export const name = 'ksadk-plugin-companions'
+
+// Private supervisor material never enters Loader entry.config or the client
+// boot graph. Remove it before plugins can launch delegated child processes.
+const configuration = JSON.parse(process.env.KSADK_DSH_COMPANION_CONFIGURATION || 'null')
+delete process.env.KSADK_DSH_COMPANION_CONFIGURATION
+
+export function apply(ctx) {
+  const bridge = new CompanionBridge(configuration)
+  ctx.provide('pluginCompanions', bridge)
+  ctx.effect(() => () => bridge.dispose())
+}

ksadk/plugins/providers/bundles/ksadk-dsh-studio/client.js

@@ -0,0 +1,115 @@
+window.__ModuleLoader__.load({
+  id: '@kingsoftcloud/dsh-app-studio',
+  factory: require => {
+    const { Component, createElement, Fragment, useEffect, useRef, useState } = require('react');
+    const { createPortal } = require('react-dom');
+
+    class PluginSurfaceBoundary extends Component {
+      state = { failed: false };
+      static getDerivedStateFromError() { return { failed: true }; }
+      render() {
+        return this.state.failed
+          ? createElement('p', { role: 'alert' }, '此插件页面加载失败，可以返回列表选择其他插件。')
+          : this.props.children;
+      }
+    }
+
+    function sectionLabel(entry) {
+      try {
+        const label = typeof entry.options.label === 'function' ? entry.options.label() : entry.options.label;
+        return typeof label === 'string' && label ? label : entry.options.id;
+      } catch { return entry.options.id; }
+    }
+
+    function apply(ctx) {
+      const mounts = new Map();
+      const listeners = new Set();
+      const notify = () => listeners.forEach(listener => listener());
+      const workspaceListeners = new Set();
+      const notifyWorkspace = () => {
+        workspaceListeners.forEach(listener => listener());
+        notify();
+        window.dispatchEvent?.(new Event('studio:workspace-changed'));
+      };
+      function packageForSection(entry) {
+        const registrant = entry.registrant || entry.options.registrant;
+        if (!registrant) return undefined;
+        // Cordis uses the client export's name, which need not equal its npm ID.
+        // Resolve only the official boot graph; ambiguous names stay unassigned.
+        const matches = (window.__DSH_BOOT__?.entries || []).filter(row => {
+          try { return require(row.id).name === registrant; }
+          catch { return false; } // A deferred module may not have arrived yet.
+        });
+        return matches.length === 1 ? matches[0].id : undefined;
+      }
+      const bridge = {
+        sections: () => ctx.slots.entriesOfSlot('settings.section')
+          .filter(entry => typeof entry.options.id === 'string' && !['general', 'models', 'plugins', 'agent-presets'].includes(entry.options.id))
+          .sort((a, b) => (a.options.order || 0) - (b.options.order || 0))
+          .map(entry => ({
+            id: entry.options.id,
+            label: sectionLabel(entry),
+            // Display/navigation attribution only, never an authorization key.
+            pluginId: packageForSection(entry),
+          })),
+        subscribe: listener => { listeners.add(listener); return () => listeners.delete(listener); },
+        attach: (id, container, close) => {
+          const key = Symbol(id);
+          mounts.set(key, { id, container, props: { close }, slot: 'settings.section' }); notify();
+          return () => { mounts.delete(key); notify(); };
+        },
+        workspacePages: () => ctx.slots.entriesOfSlot('studio.workspace.page')
+          .filter(entry => typeof entry.options.id === 'string')
+          .sort((a, b) => (a.options.order || 0) - (b.options.order || 0))
+          .map(entry => ({ id: entry.options.id, label: sectionLabel(entry),
+            pluginId: packageForSection(entry), order: entry.options.order || 0 })),
+        subscribeWorkspace: listener => {
+          workspaceListeners.add(listener); return () => workspaceListeners.delete(listener);
+        },
+        attachWorkspace: (id, container, props = {}) => {
+          const key = Symbol(id);
+          mounts.set(key, { id, container, props, slot: 'studio.workspace.page' }); notify();
+          return () => { mounts.delete(key); notify(); };
+        },
+      };
+      function StudioRoot({ renderSlot }) {
+        const container = useRef(null);
+        const [, update] = useState(0);
+        const [error, setError] = useState('');
+        useEffect(() => {
+          let disposed = false, unmount;
+          const redraw = () => update(value => value + 1);
+          const detach = bridge.subscribe(redraw);
+          const unsubscribe = ctx.slots.subscribe('settings.section', notify);
+          const unsubscribeWorkspace = ctx.slots.subscribe('studio.workspace.page', notifyWorkspace);
+          window.__STUDIO_DSH__ = bridge;
+          window.dispatchEvent?.(new Event('studio:bridge-ready'));
+          const mount = () => {
+            if (!window.__STUDIO_APP__ || !container.current) return;
+            window.removeEventListener('studio:app-ready', mount);
+            Promise.resolve(window.__STUDIO_APP__.mount(container.current)).then(dispose => {
+              if (disposed) dispose(); else unmount = dispose;
+            }).catch(cause => setError(String(cause)));
+          };
+          window.addEventListener('studio:app-ready', mount); mount();
+          return () => {
+            disposed = true; detach(); unsubscribe(); unsubscribeWorkspace(); unmount?.();
+            window.removeEventListener('studio:app-ready', mount);
+            if (window.__STUDIO_DSH__ === bridge) delete window.__STUDIO_DSH__;
+            window.dispatchEvent?.(new Event('studio:workspace-changed'));
+          };
+        }, []);
+        return createElement(Fragment, null,
+          createElement('div', { ref: container, className: 'studio-native-root', style: { height: '100vh' } }, error || null),
+          ...[...mounts.values()].map(({ id, container, props, slot }) => createPortal(
+            createElement(PluginSurfaceBoundary, { key: id }, renderSlot(slot, props, { only: id })), container, id)),
+        );
+      }
+      ctx.slots.register({ name: 'root', priority: -100, children: {
+        'settings.section': { kind: 'list', scope: 'root' },
+        'studio.workspace.page': { kind: 'list', scope: 'root' },
+      } }, StudioRoot);
+    }
+    return { name: 'studio-app', inject: ['slots'], apply };
+  },
+});

ksadk/plugins/providers/bundles/ksadk-dsh-studio/index.mjs

@@ -0,0 +1,19 @@
+import { readFileSync } from 'node:fs';
+
+export const name = 'studio-app';
+export const inject = ['webServer'];
+
+// Application composition only. All plugin services remain owned by Core.
+export async function apply(ctx, config) {
+  const assetTags = () => {
+    const html = readFileSync(config.indexPath, 'utf8');
+    const assets = html.match(/<script\b[^>]*type="module"[^>]*><\/script>|<link\b[^>]*rel="(?:stylesheet|modulepreload)"[^>]*>/g) || [];
+    if (!assets.length) throw new Error('Studio frontend assets are missing; build Studio first');
+    return assets.join('');
+  };
+  assetTags(); // Validate at boot, but do not retain filenames across frontend rebuilds.
+  ctx.on('webserver/index-inject', table => table.push({
+    kind: 'html', placement: 'head',
+    html: '<script>window.__STUDIO_DSH_BOOT__=true</script>' + assetTags(),
+  }));
+}

ksadk/plugins/providers/bundles/ksadk-dsh-studio/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@kingsoftcloud/dsh-app-studio",
+  "version": "1.0.0",
+  "type": "module",
+  "exports": { ".": "./index.mjs", "./client": "./client.js" },
+  "dsh": { "client": { "inject": ["@deepseek-ai/dsh-client-ui-renderer"], "platform": "web" } }
+}

ksadk/plugins/providers/bundles/ksadk-harness/index.mjs

@@ -14,6 +14,6 @@ export function apply(ctx) {
   // The DSH Profile owns discovery and lifecycle. KsADK consumes this
   // contribution through its frozen provider-host bridge; the existing
   // RuntimeAdapter remains the execution backend during migration.
-  ctx.provide('ksadkAgentProvider', contribution)
+  ctx.provide('ksadkHarnessAgentProvider', contribution)
   ctx.effect(() => () => {})
 }