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

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

@@ -0,0 +1,175 @@
+export const name = 'dsh-memory'
+export const inject = ['tools', 'platformResources']
+
+export function apply(ctx) {
+  for (const operation of ['update_memory', 'delete_memory']) {
+    const updating = operation === 'update_memory'
+    ctx.effect(() => ctx.platformResources.registerTool(operation, operation))
+    ctx.tools.register({
+      name: operation,
+      description: updating
+        ? 'Update a real memory ID recalled in this activation, after host approval. No versioned CAS is supported. Use only the returned new ID; if absent, search again.'
+        : 'Soft-delete a real memory ID recalled in this activation, after host approval. This does not guarantee physical erasure.',
+      parameters: {
+        type: 'object', properties: {
+          memoryId: { type: 'string', minLength: 1, maxLength: 256 },
+          ...(updating ? { content: { type: 'string', minLength: 1, maxLength: 8192 } } : {}),
+        },
+        required: updating ? ['memoryId', 'content'] : ['memoryId'], additionalProperties: false,
+      },
+      output: {
+        schema: {
+          type: 'object', properties: {
+            status: { type: 'string', enum: ['succeeded', 'failed', 'unknown'] },
+            operationId: { type: 'string' }, memoryId: { type: 'string' },
+            newMemoryId: { oneOf: [{ type: 'string' }, { type: 'null' }] },
+            errorCode: { oneOf: [{ type: 'string' }, { type: 'null' }] },
+          },
+          required: ['status', 'operationId', 'memoryId', 'newMemoryId', 'errorCode'],
+          additionalProperties: false,
+        },
+        render(_args, result) {
+          const text = result.status === 'unknown'
+            ? 'Memory mutation outcome is unknown. Do not submit it again automatically.'
+            : result.status === 'failed' ? 'Memory mutation was not completed. Search again before proposing another change.'
+            : !updating ? 'Memory soft-deletion confirmed. This receipt does not prove physical erasure.'
+            : result.newMemoryId ? `Memory update confirmed. Returned record ID: ${result.newMemoryId}.`
+            : 'Memory update confirmed, but its resulting record ID is unavailable. Search again before another change.'
+          return [{ type: 'text', text }]
+        },
+      },
+      isConcurrencySafe: () => false,
+      async execute(args, execution) {
+        const result = await ctx.platformResources.call(operation, args, { signal: execution.signal })
+        if (!['succeeded', 'failed', 'unknown'].includes(result.status)
+          || !/^[0-9a-f]{64}$/.test(result.operationId)
+          || (result.memoryId !== undefined && result.memoryId !== args.memoryId)
+          || (result.newMemoryId !== undefined && typeof result.newMemoryId !== 'string')
+          || (result.status !== 'succeeded' && result.newMemoryId)
+          || (!updating && result.newMemoryId)
+          || (result.errorCode != null && ![
+            'MEMORY_MUTATION_UNKNOWN', 'MEMORY_RECORD_NOT_OBSERVED', 'MEMORY_RECORD_NOT_FOUND',
+          ].includes(result.errorCode))) throw new Error('MEMORY_RESPONSE_INVALID')
+        return {
+          status: result.status, operationId: result.operationId,
+          memoryId: args.memoryId, newMemoryId: result.newMemoryId || null,
+          errorCode: result.errorCode ?? (result.status === 'unknown' ? 'MEMORY_MUTATION_UNKNOWN' : null),
+        }
+      },
+    })
+  }
+  ctx.effect(() => ctx.platformResources.registerTool('memory_status', 'memory_status'))
+  ctx.tools.register({
+    name: 'memory_status',
+    description: 'Check an owned memory submission receipt without resubmitting it. Extraction completion does not prove search indexing is ready.',
+    parameters: {
+      type: 'object', properties: { operationId: { type: 'string', pattern: '^[0-9a-f]{64}$' } },
+      required: ['operationId'], additionalProperties: false,
+    },
+    output: {
+      schema: {
+        type: 'object', properties: {
+          operationId: { type: 'string' }, status: { type: 'string' },
+          extractionStatus: { type: 'string' }, searchable: { type: 'boolean' },
+          errorCode: { oneOf: [{ type: 'string' }, { type: 'null' }] },
+        },
+        required: ['operationId', 'status', 'extractionStatus', 'searchable', 'errorCode'],
+        additionalProperties: false,
+      },
+      render(_args, result) {
+        return [{ type: 'text', text: `Memory extraction: ${result.extractionStatus}. Search indexing has not been confirmed.` }]
+      },
+    },
+    isConcurrencySafe: () => true,
+    execute(args, execution) {
+      return ctx.platformResources.call('memory_status', args, { signal: execution.signal })
+    },
+  })
+  ctx.effect(() => ctx.platformResources.registerTool('save_memory', 'save_memory'))
+  ctx.tools.register({
+    name: 'save_memory',
+    description: 'Submit an explicitly authorized memory for this user. Acceptance is pending extraction, not confirmation that it can be recalled.',
+    parameters: {
+      type: 'object', properties: { content: { type: 'string', minLength: 1, maxLength: 8192 } },
+      required: ['content'], additionalProperties: false,
+    },
+    output: {
+      schema: {
+        type: 'object', properties: {
+          status: { type: 'string', enum: ['accepted_pending', 'unknown', 'searchable', 'failed'] },
+          operationId: { type: 'string' }, searchable: { type: 'boolean' },
+        },
+        required: ['status', 'operationId', 'searchable'], additionalProperties: false,
+      },
+      render(_args, result) {
+        const text = result.status === 'accepted_pending' ? 'Memory accepted; extraction is pending.'
+          : result.status === 'searchable' ? 'Memory indexing confirmed.'
+          : result.status === 'failed' ? 'Memory submission failed.'
+          : 'Memory submission outcome is unknown. Do not submit it again automatically.'
+        return [{ type: 'text', text }]
+      },
+    },
+    isConcurrencySafe: () => false,
+    async execute(args, execution) {
+      const result = await ctx.platformResources.call('save_memory', args, { signal: execution.signal })
+      if (!['accepted_pending', 'unknown', 'searchable', 'failed'].includes(result.status)
+        || typeof result.operationId !== 'string') throw new Error('MEMORY_RESPONSE_INVALID')
+      return {
+        status: result.status, operationId: result.operationId,
+        searchable: result.status === 'searchable',
+      }
+    },
+  })
+  ctx.effect(() => ctx.platformResources.registerTool('load_memory', 'load_memory'))
+  ctx.tools.register({
+    name: 'load_memory',
+    description: 'Recall memories for the authenticated user from this Agent’s bound memory instance.',
+    parameters: {
+      type: 'object',
+      properties: { query: { type: 'string', maxLength: 16000 } },
+      required: ['query'], additionalProperties: false,
+    },
+    output: {
+      schema: {
+        type: 'object',
+        properties: {
+          status: { type: 'string', enum: ['ok', 'empty', 'failed', 'unauthorized'] },
+          items: { type: 'array', items: {
+            type: 'object',
+            properties: {
+              memoryId: { type: 'string' }, content: { type: 'string' },
+              score: { oneOf: [{ type: 'number' }, { type: 'null' }] },
+              version: { oneOf: [{ type: 'integer' }, { type: 'null' }] },
+            },
+            required: ['memoryId', 'content', 'score', 'version'], additionalProperties: false,
+          } },
+          truncated: { type: 'boolean' },
+          errorCode: { oneOf: [{ type: 'string' }, { type: 'null' }] },
+        },
+        required: ['status', 'items', 'truncated', 'errorCode'], additionalProperties: false,
+      },
+      render(_args, result) {
+        const text = result.status === 'empty' ? 'No matching memories found.'
+          : result.status !== 'ok' ? 'Memory retrieval unavailable.'
+          : result.items.map(item => `[${item.memoryId}] ${item.content}`).join('\n\n')
+        return [{ type: 'text', text }]
+      },
+    },
+    isConcurrencySafe: () => true,
+    async execute(args, execution) {
+      const result = await ctx.platformResources.call('load_memory', args, { signal: execution.signal })
+      if (!['ok', 'failed', 'unauthorized'].includes(result.status) || !Array.isArray(result.records)) {
+        throw new Error('MEMORY_RESPONSE_INVALID')
+      }
+      // Tenant/user partition and internal provenance remain host-side.
+      const items = result.status === 'ok' ? result.records.map(record => ({
+        memoryId: record.memory_id, content: record.content,
+        score: record.metadata?.score ?? null, version: record.version ?? null,
+      })) : []
+      return {
+        status: result.status === 'ok' && items.length === 0 ? 'empty' : result.status,
+        items, truncated: Boolean(result.truncated_by_budget), errorCode: result.error_code ?? null,
+      }
+    },
+  })
+}

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

@@ -0,0 +1,16 @@
+{
+  "name": "@kingsoftcloud/dsh-memory",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Private development bundle for Agent-bound memory tools",
+  "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.1",
+    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
+    "@kingsoftcloud/dsh-platform-resources": "0.1.0"
+  },
+  "dsh": {"bundle": {"patch": "./cordis.patch.yml"}}
+}

ksadk/plugins/providers/bundles/dsh-platform-resources/client.mjs

@@ -0,0 +1,166 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { randomUUID } from 'node:crypto'
+import { createConnection } from 'node:net'
+
+const MAX_BYTES = 1024 * 1024
+const OPERATIONS = new Set([
+  'search_knowledge_base', 'load_memory', 'save_memory', 'update_memory',
+  'delete_memory', 'memory_status', 'list_skill_spaces', 'list_skills',
+  'search_skills', 'load_skill', 'read_skill_resource', 'execute_skills', 'read_skill_artifact',
+])
+
+export class ResourceBridgeError extends Error {
+  constructor(code) { super(code); this.code = code }
+}
+
+function assertJson(value, depth = 0, parents = new Set()) {
+  if (depth > 64) throw new ResourceBridgeError('RESOURCE_REQUEST_INVALID')
+  if (value === null || typeof value === 'boolean') return
+  if (typeof value === 'string') {
+    if (!value.isWellFormed()) throw new ResourceBridgeError('RESOURCE_REQUEST_INVALID')
+    return
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) return
+  if (typeof value !== 'object' || parents.has(value)) {
+    throw new ResourceBridgeError('RESOURCE_REQUEST_INVALID')
+  }
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) {
+    throw new ResourceBridgeError('RESOURCE_REQUEST_INVALID')
+  }
+  parents.add(value)
+  for (const [key, child] of Object.entries(value)) {
+    assertJson(key, depth + 1, parents)
+    assertJson(child, depth + 1, parents)
+  }
+  parents.delete(value)
+}
+
+export class ResourceBridge {
+  #context = new AsyncLocalStorage()
+  #pending = new Set()
+  #closed = false
+  #socketPath
+  #tools = new Map()
+
+  constructor(socketPath) {
+    if (typeof socketPath !== 'string' || !socketPath.startsWith('/') || socketPath.includes('\0')) {
+      throw new ResourceBridgeError('RESOURCE_SOCKET_INVALID')
+    }
+    this.#socketPath = socketPath
+  }
+
+  registerTool(name, operation) {
+    if (!/^[A-Za-z0-9_.:-]{1,128}$/.test(name) || !OPERATIONS.has(operation) || this.#tools.has(name)) {
+      throw new ResourceBridgeError('RESOURCE_TOOL_INVALID')
+    }
+    this.#tools.set(name, operation)
+    return () => this.#tools.delete(name)
+  }
+
+  operationForTool(name) { return this.#tools.get(name) }
+
+  withInvocation(context, callback) {
+    // Only the trusted executor/MCP adapter establishes this context. The
+    // opaque handle still requires independent authorization by Python.
+    if (!context || typeof context.handle !== 'string' ||
+        !/^[A-Za-z0-9_-]{32,256}$/.test(context.handle) ||
+        !Number.isSafeInteger(context.deadline) || context.deadline <= Date.now() ||
+        (context.signal != null && !(context.signal instanceof AbortSignal))) {
+      throw new ResourceBridgeError('RESOURCE_CONTEXT_REQUIRED')
+    }
+    return this.#context.run(Object.freeze({
+      handle: context.handle, deadline: context.deadline, signal: context.signal,
+    }), callback)
+  }
+
+  async call(operation, args = {}, { signal } = {}) {
+    return this.#request(operation, args, { signal }, false)
+  }
+
+  async check(operation) {
+    return this.#request(operation, {}, {}, true)
+  }
+
+  async #request(operation, args, { signal }, checkOnly) {
+    if (this.#closed) throw new ResourceBridgeError('RESOURCE_BRIDGE_CLOSED')
+    if (this.#pending.size >= 64) throw new ResourceBridgeError('RESOURCE_BUSY')
+    const context = this.#context.getStore()
+    if (!context) throw new ResourceBridgeError('RESOURCE_CONTEXT_REQUIRED')
+    if (signal != null && !(signal instanceof AbortSignal)) {
+      throw new ResourceBridgeError('RESOURCE_REQUEST_INVALID')
+    }
+    const signals = [context.signal, signal].filter(Boolean)
+    const callSignal = signals.length ? AbortSignal.any(signals) : undefined
+    if (!OPERATIONS.has(operation) || !args || Array.isArray(args) || typeof args !== 'object') {
+      throw new ResourceBridgeError('RESOURCE_REQUEST_INVALID')
+    }
+    assertJson(args)
+    const requestId = randomUUID()
+    const deadline = Math.min(context.deadline, Date.now() + (operation === 'execute_skills' ? 900_000 : 60_000))
+    if (deadline <= Date.now()) throw new ResourceBridgeError('RESOURCE_DEADLINE_EXCEEDED')
+    const body = Buffer.from(JSON.stringify({
+      v: 1, requestId, deadline, operation, handle: context.handle, arguments: args,
+      ...(checkOnly ? { checkOnly: true } : {}),
+    }), 'utf8')
+    if (body.length > MAX_BYTES) throw new ResourceBridgeError('RESOURCE_REQUEST_INVALID')
+    const prefix = Buffer.alloc(4)
+    prefix.writeUInt32BE(body.length)
+    return new Promise((resolve, reject) => {
+      let socket
+      let timer
+      let settled = false
+      let received = Buffer.alloc(0)
+      let expected
+      const finish = (error, result) => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        callSignal?.removeEventListener('abort', abort)
+        this.#pending.delete(abort)
+        socket?.destroy()
+        if (error) reject(error)
+        else resolve(result)
+      }
+      const fail = code => finish(new ResourceBridgeError(code))
+      const abort = () => fail('RESOURCE_CANCELLED')
+      if (callSignal?.aborted) return abort()
+      this.#pending.add(abort)
+      callSignal?.addEventListener('abort', abort, { once: true })
+      timer = setTimeout(() => fail('RESOURCE_DEADLINE_EXCEEDED'), Math.max(1, deadline - Date.now()))
+      socket = createConnection({ path: this.#socketPath })
+      socket.once('connect', () => socket.write(Buffer.concat([prefix, body])))
+      socket.once('error', () => fail('RESOURCE_TRANSPORT_FAILED'))
+      socket.once('close', () => { if (!settled) fail('RESOURCE_TRANSPORT_FAILED') })
+      socket.on('data', chunk => {
+        if (received.length + chunk.length > MAX_BYTES + 4) return fail('RESOURCE_RESPONSE_INVALID')
+        received = Buffer.concat([received, chunk])
+        if (expected === undefined && received.length >= 4) {
+          expected = received.readUInt32BE(0)
+          if (!expected || expected > MAX_BYTES) return fail('RESOURCE_RESPONSE_INVALID')
+        }
+        if (expected === undefined || received.length < expected + 4) return
+        if (received.length !== expected + 4) return fail('RESOURCE_RESPONSE_INVALID')
+        try {
+          const response = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(received.subarray(4)))
+          if (response?.v !== 1 || response.requestId !== requestId) return fail('RESOURCE_RESPONSE_INVALID')
+          if (response.error) {
+            const code = response.error.code
+            return fail(typeof code === 'string' && /^RESOURCE_[A-Z_]{1,64}$/.test(code)
+              ? code : 'RESOURCE_RESPONSE_INVALID')
+          }
+          if (!response.result || typeof response.result !== 'object' || Array.isArray(response.result)) {
+            return fail('RESOURCE_RESPONSE_INVALID')
+          }
+          assertJson(response.result)
+          finish(null, response.result)
+        } catch { fail('RESOURCE_RESPONSE_INVALID') }
+      })
+    })
+  }
+
+  dispose() {
+    this.#closed = true
+    for (const abort of [...this.#pending]) abort()
+    this.#context.disable()
+  }
+}

ksadk/plugins/providers/bundles/dsh-platform-resources/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-platform-resources
+      name: '@kingsoftcloud/dsh-platform-resources'

ksadk/plugins/providers/bundles/dsh-platform-resources/index.mjs

@@ -0,0 +1,9 @@
+import { ResourceBridge } from './client.mjs'
+
+export const name = 'dsh-platform-resources'
+
+export function apply(ctx, config = {}) {
+  const bridge = new ResourceBridge(config.socketPath)
+  ctx.provide('platformResources', bridge)
+  ctx.effect(() => () => bridge.dispose())
+}

ksadk/plugins/providers/bundles/dsh-platform-resources/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@kingsoftcloud/dsh-platform-resources",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Private development bundle for host-authorized platform resource IPC",
+  "exports": {".": "./index.mjs", "./client": "./client.mjs", "./cordis.patch.yml": "./cordis.patch.yml"},
+  "files": ["index.mjs", "client.mjs", "cordis.patch.yml"],
+  "engines": {"node": ">=22.19.0"},
+  "peerDependencies": {"@deepseek-ai/cordis": "^4.0.1"},
+  "dsh": {"bundle": {"patch": "./cordis.patch.yml"}}
+}

ksadk/plugins/providers/bundles/dsh-skill-center/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-skill-center
+      name: '@kingsoftcloud/dsh-skill-center'

ksadk/plugins/providers/bundles/dsh-skill-center/index.mjs

@@ -0,0 +1,125 @@
+export const name = 'dsh-skill-center'
+export const inject = ['tools', 'platformResources']
+
+const skillId = { type: 'string', minLength: 1, maxLength: 256 }
+const artifactProperties = {
+  artifactId: { type: 'string' }, name: { type: 'string' },
+  size: { type: 'integer' }, sha256: { type: 'string' },
+}
+const resourceOutput = {
+  type: 'object', properties: {
+    status: { type: 'string', enum: ['ok'] }, skillId: { type: 'string' },
+    versionId: { type: 'string' }, contentHash: { type: 'string' }, path: { type: 'string' },
+    content: { type: 'string' }, truncated: { type: 'boolean' },
+    nextOffset: { oneOf: [{ type: 'integer' }, { type: 'null' }] },
+  },
+  required: ['status', 'skillId', 'versionId', 'contentHash', 'path', 'content', 'truncated', 'nextOffset'],
+  additionalProperties: false,
+}
+
+export function apply(ctx) {
+  const definitions = [
+    {
+      name: 'execute_skills', description: 'Execute selected locked Skills in the Build’s isolated runtime after host approval. Discovery selections must first be loaded and recorded. An unknown outcome must not be retried as a new operation.',
+      parameters: { type: 'object', properties: {
+        workflowPrompt: { type: 'string', minLength: 1, maxLength: 16000 },
+        skillIds: { type: 'array', items: skillId, minItems: 1, maxItems: 32, uniqueItems: true },
+      }, required: ['workflowPrompt', 'skillIds'], additionalProperties: false },
+      schema: { type: 'object', properties: {
+        status: { type: 'string', enum: ['succeeded', 'unknown', 'failed'] },
+        operationId: { type: 'string' }, replayed: { type: 'boolean' },
+        artifacts: { type: 'array', items: { type: 'object', properties: artifactProperties,
+          required: ['artifactId', 'name', 'size', 'sha256'], additionalProperties: false } },
+      }, required: ['status', 'operationId'], additionalProperties: false },
+      render: result => result.status === 'succeeded'
+        ? `Skill execution completed. Operation: ${result.operationId}. Artifacts: ${(result.artifacts ?? []).map(item => `${item.name} (${item.artifactId})`).join(', ') || 'none'}`
+        : `Skill execution outcome: ${result.status}. Operation: ${result.operationId}. Do not submit a new execution to recover this result.`,
+    },
+    {
+      name: 'read_skill_artifact', description: 'Read a bounded base64 chunk of an artifact from an authorized Skill execution. Follow nextOffset to retrieve the complete file.',
+      parameters: { type: 'object', properties: {
+        operationId: { type: 'string', pattern: '^[0-9a-f]{64}$' },
+        artifactId: { type: 'string', pattern: '^[0-9a-f]{64}$' },
+        offset: { type: 'integer', minimum: 0, maximum: 20971520 },
+        maxBytes: { type: 'integer', minimum: 1, maximum: 32768 },
+      }, required: ['operationId', 'artifactId'], additionalProperties: false },
+      schema: { type: 'object', properties: {
+        ...artifactProperties, operationId: { type: 'string' }, encoding: { type: 'string', enum: ['base64'] },
+        content: { type: 'string' }, offset: { type: 'integer' },
+        nextOffset: { oneOf: [{ type: 'integer' }, { type: 'null' }] },
+      }, required: ['artifactId', 'name', 'size', 'sha256', 'operationId', 'encoding', 'content', 'offset', 'nextOffset'], additionalProperties: false },
+      render: result => `${result.name} — base64 at byte ${result.offset}:\n${result.content}\nNext offset: ${result.nextOffset ?? 'end'}`,
+    },
+    {
+      name: 'list_skills', description: 'List Skills allowed by this Agent binding: Build-locked packages in pinned mode, or the admitted space in discovery mode.',
+      parameters: { type: 'object', properties: {}, additionalProperties: false },
+      schema: {
+        type: 'object', properties: {
+          status: { type: 'string', enum: ['ok'] }, truncated: { type: 'boolean' },
+          items: { type: 'array', items: {
+            type: 'object', properties: {
+              skillId: { type: 'string' }, name: { type: 'string' }, versionId: { type: 'string' }, contentHash: { type: 'string' },
+            }, required: ['skillId', 'name', 'versionId', 'contentHash'], additionalProperties: false,
+          } },
+        }, required: ['status', 'items', 'truncated'], additionalProperties: false,
+      },
+      render: result => result.items.map(item => `${item.name} (${item.skillId}@${item.versionId})`).join('\n') || 'No Skills are available.',
+    },
+    {
+      name: 'search_skills', description: 'Search names and descriptions of Skills allowed by this Agent binding using metadata matching.',
+      parameters: {
+        type: 'object', properties: {
+          query: { type: 'string', minLength: 1, maxLength: 16000 },
+          maxResults: { type: 'integer', minimum: 1, maximum: 32 },
+        }, required: ['query'], additionalProperties: false,
+      },
+      schema: {
+        type: 'object', properties: {
+          status: { type: 'string', enum: ['ok'] }, truncated: { type: 'boolean' },
+          items: { type: 'array', items: {
+            type: 'object', properties: {
+              skillId: { type: 'string' }, name: { type: 'string' }, versionId: { type: 'string' },
+              contentHash: { type: 'string' }, description: { type: 'string' },
+              score: { type: 'integer' }, reason: { type: 'string' },
+            }, required: ['skillId', 'name', 'versionId', 'contentHash', 'description', 'score', 'reason'],
+            additionalProperties: false,
+          } },
+        }, required: ['status', 'items', 'truncated'], additionalProperties: false,
+      },
+      render: result => result.items.map(item => `${item.name} (${item.skillId}@${item.versionId}): ${item.description}`).join('\n') || 'No Skill matches this query.',
+    },
+    {
+      name: 'load_skill', description: 'Read an allowed Skill’s SKILL.md and fix its version for this run when using discovery. Follow nextOffset with read_skill_resource if truncated.',
+      parameters: { type: 'object', properties: { skillId }, required: ['skillId'], additionalProperties: false },
+      schema: resourceOutput, render: result => result.content,
+    },
+    {
+      name: 'read_skill_resource', description: 'Read a UTF-8 text file from a selected Skill package by relative path. This does not execute scripts.',
+      parameters: {
+        type: 'object', properties: {
+          skillId, path: { type: 'string', minLength: 1, maxLength: 1024 },
+          offset: { type: 'integer', minimum: 0, maximum: 1048576 },
+          maxChars: { type: 'integer', minimum: 1, maximum: 64000 },
+        }, required: ['skillId', 'path'], additionalProperties: false,
+      },
+      schema: resourceOutput, render: result => result.content,
+    },
+  ]
+  for (const definition of definitions) {
+    ctx.effect(() => ctx.platformResources.registerTool(definition.name, definition.name))
+    ctx.tools.register({
+      name: definition.name, description: definition.description, parameters: definition.parameters,
+      output: { schema: definition.schema, render: (_args, result) => [{ type: 'text', text: definition.render(result) }] },
+      isConcurrencySafe: () => definition.name !== 'execute_skills',
+      async execute(args, execution) {
+        const result = await ctx.platformResources.call(definition.name, args, { signal: execution.signal })
+        if (definition.name === 'execute_skills') {
+          if (!['succeeded', 'unknown', 'failed'].includes(result.status)) throw new Error('SKILL_EXECUTION_UNAVAILABLE')
+        } else if (definition.name !== 'read_skill_artifact' && result.status !== 'ok') {
+          throw new Error('SKILL_RESOURCE_UNAVAILABLE')
+        }
+        return result
+      },
+    })
+  }
+}

ksadk/plugins/providers/bundles/dsh-skill-center/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@kingsoftcloud/dsh-skill-center",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "description": "Private development bundle for Build-bound Skill consumption",
+  "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.1",
+    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2",
+    "@kingsoftcloud/dsh-platform-resources": "0.1.0"
+  },
+  "dsh": {"bundle": {"patch": "./cordis.patch.yml"}}
+}

ksadk/plugins/providers/bundles/ksadk-dsh-capability-host/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: ksadk-dsh-capability-host
+      name: '@kingsoftcloud/ksadk-dsh-capability-host'