@genkaku/dsh-user-plugin 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GenKaKu Labs
+
+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/dist/adapter.d.ts

@@ -0,0 +1,44 @@
+/**
+ * GenKaKu as a first-class DeepSeek Harness model provider.
+ *
+ * The harness asks an adapter for StreamChunks in its own vocabulary; the
+ * network speaks OpenAI chat-completions over the plugin's local bridge. This
+ * adapter is the whole translation and the only place that knows both dialects.
+ *
+ * All traffic goes through the bridge (127.0.0.1:<port>/v1) instead of dialing a
+ * worker directly, so escrow opening, per-minute billing and settlement stay in
+ * one implementation.
+ */
+import type { FinishReason, GenerateOptions, LlmModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+export type GenkakuAdapterOptions = {
+    /** Base URL of the plugin's local bridge, e.g. http://127.0.0.1:47821/v1 */
+    baseUrl: () => string;
+    log?: (line: string) => void;
+};
+/**
+ * Project harness messages onto the OpenAI chat shape the bridge accepts.
+ *
+ * `developer` messages carry tool additions and removals, which the loop already
+ * expresses through GenerateOptions.tools; they are skipped rather than sent as
+ * empty turns.
+ */
+export declare function toOpenAiMessages(options: GenerateOptions): Array<Record<string, unknown>>;
+export declare function finishOf(reason: string | null | undefined, sawToolCall: boolean): FinishReason;
+export declare class GenkakuAdapter extends LlmAdapter {
+    private readonly options;
+    constructor(options: GenkakuAdapterOptions);
+    providerInfo(provider: string): {
+        id: string;
+        name: string;
+    };
+    /**
+     * The live marketplace board. A chat-only model is still listed: it is usable,
+     * it just cannot drive an agent loop, so it carries a warning badge instead of
+     * being hidden.
+     */
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    /** Stream one completion from the network. */
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAEV,YAAY,EACZ,eAAe,EACf,YAAY,EAEZ,WAAW,EAGZ,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAqBjD,MAAM,MAAM,qBAAqB,GAAG;IAClC,4EAA4E;IAC5E,OAAO,EAAE,MAAM,MAAM,CAAA;IACrB,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC7B,CAAA;AAgBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAqBzF;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,WAAW,EAAE,OAAO,GAAG,YAAY,CAI9F;AAED,qBAAa,cAAe,SAAQ,UAAU;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,qBAAqB;IAIlD,YAAY,CAAC,QAAQ,EAAE,MAAM;;;;IAItC;;;;OAIG;IACY,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC;IAyB7E,8CAA8C;IAC9B,MAAM,CAAC,OAAO,EAAE,eAAe,GAAG,aAAa,CAAC,WAAW,CAAC;CAuH7E"}

package/dist/adapter.js

@@ -0,0 +1,226 @@
+/**
+ * GenKaKu as a first-class DeepSeek Harness model provider.
+ *
+ * The harness asks an adapter for StreamChunks in its own vocabulary; the
+ * network speaks OpenAI chat-completions over the plugin's local bridge. This
+ * adapter is the whole translation and the only place that knows both dialects.
+ *
+ * All traffic goes through the bridge (127.0.0.1:<port>/v1) instead of dialing a
+ * worker directly, so escrow opening, per-minute billing and settlement stay in
+ * one implementation.
+ */
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+function textOf(blocks) {
+    return blocks.map(block => (block.type === 'text' ? block.text : '')).join('');
+}
+function toolCallsOf(blocks) {
+    return blocks
+        .filter((block) => block.type === 'tool-call')
+        .map(block => ({
+        id: block.id,
+        type: 'function',
+        function: { name: block.name, arguments: block.arguments },
+    }));
+}
+/**
+ * Project harness messages onto the OpenAI chat shape the bridge accepts.
+ *
+ * `developer` messages carry tool additions and removals, which the loop already
+ * expresses through GenerateOptions.tools; they are skipped rather than sent as
+ * empty turns.
+ */
+export function toOpenAiMessages(options) {
+    const out = [];
+    if (options.system != null && options.system !== '')
+        out.push({ role: 'system', content: options.system });
+    for (const message of options.messages) {
+        if (message.role === 'developer')
+            continue;
+        if (message.role === 'tool') {
+            out.push({ role: 'tool', tool_call_id: message.toolCallId, content: textOf(message.content) });
+            continue;
+        }
+        if (message.role === 'assistant') {
+            const calls = toolCallsOf(message.content);
+            out.push({
+                role: 'assistant',
+                content: textOf(message.content),
+                ...(calls.length === 0 ? {} : { tool_calls: calls }),
+            });
+            continue;
+        }
+        out.push({ role: message.role, content: textOf(message.content) });
+    }
+    return out;
+}
+export function finishOf(reason, sawToolCall) {
+    if (sawToolCall || reason === 'tool_calls')
+        return { kind: 'tool-calls' };
+    if (reason === 'length')
+        return { kind: 'max-tokens' };
+    return { kind: 'stop' };
+}
+export class GenkakuAdapter extends LlmAdapter {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    providerInfo(provider) {
+        return { id: provider, name: 'GenKaKu Network' };
+    }
+    /**
+     * The live marketplace board. A chat-only model is still listed: it is usable,
+     * it just cannot drive an agent loop, so it carries a warning badge instead of
+     * being hidden.
+     */
+    async listModels(provider) {
+        try {
+            const res = await fetch(`${this.options.baseUrl()}/models`);
+            if (!res.ok)
+                return [];
+            const body = (await res.json());
+            return (body.data ?? []).map((model) => {
+                const tier = model.genkaku?.tier ?? 'chat';
+                const size = model.genkaku?.parameterSize;
+                const bits = [size, tier === 'agent' ? 'agent-ready' : undefined].filter(Boolean);
+                return {
+                    provider,
+                    id: model.id,
+                    name: model.id,
+                    ...(bits.length === 0 ? {} : { description: bits.join(' · ') }),
+                    ...(tier === 'chat'
+                        ? { badge: { text: { en: 'not for agents', zh: '不適用於 agent' }, tone: 'warning' } }
+                        : {}),
+                };
+            });
+        }
+        catch (error) {
+            this.options.log?.(`genkaku adapter: model listing failed (${String(error)})`);
+            return [];
+        }
+    }
+    /** Stream one completion from the network. */
+    async *stream(options) {
+        const body = {
+            model: options.model,
+            stream: true,
+            messages: toOpenAiMessages(options),
+            ...(options.maxTokens === undefined ? {} : { max_tokens: options.maxTokens }),
+            ...(options.temperature === undefined ? {} : { temperature: options.temperature }),
+            ...(options.tools === undefined || options.tools.length === 0
+                ? {}
+                : {
+                    tools: options.tools.map(tool => ({
+                        type: 'function',
+                        function: { name: tool.name, description: tool.description, parameters: tool.parameters },
+                    })),
+                }),
+        };
+        const res = await fetch(`${this.options.baseUrl()}/chat/completions`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+        });
+        if (!res.ok || res.body == null) {
+            const detail = await res.text().catch(() => '');
+            throw new Error(`genkaku: bridge refused (${res.status}) ${detail.slice(0, 200)}`);
+        }
+        const pending = [];
+        let nextIndex = 0;
+        let textIndex = null;
+        let text = '';
+        const tools = new Map();
+        let usage = null;
+        let sawToolCall = false;
+        const closeText = () => {
+            if (textIndex == null)
+                return;
+            pending.push({ type: 'block-end', index: textIndex, block: { type: 'text', text } });
+            textIndex = null;
+            text = '';
+        };
+        const handle = (raw) => {
+            let chunk;
+            try {
+                chunk = JSON.parse(raw);
+            }
+            catch {
+                return;
+            }
+            const choice = chunk.choices?.[0];
+            const content = choice?.delta?.content;
+            if (typeof content === 'string' && content !== '') {
+                if (textIndex == null) {
+                    textIndex = nextIndex++;
+                    pending.push({ type: 'block-start', index: textIndex, blockType: 'text' });
+                }
+                text += content;
+                pending.push({ type: 'text-delta', index: textIndex, text: content });
+            }
+            for (const call of choice?.delta?.tool_calls ?? []) {
+                const slot = call.index ?? 0;
+                let entry = tools.get(slot);
+                if (entry == null) {
+                    sawToolCall = true;
+                    closeText();
+                    entry = { index: nextIndex++, id: (call.id ?? `call_${slot}`), name: call.function?.name ?? '', args: '' };
+                    tools.set(slot, entry);
+                    pending.push({ type: 'block-start', index: entry.index, blockType: 'tool-call' });
+                    pending.push({ type: 'tool-call-delta', index: entry.index, id: entry.id, name: entry.name, argumentsDelta: '' });
+                }
+                const argsDelta = call.function?.arguments ?? '';
+                if (argsDelta !== '') {
+                    entry.args += argsDelta;
+                    pending.push({ type: 'tool-call-delta', index: entry.index, id: entry.id, argumentsDelta: argsDelta });
+                }
+            }
+            if (chunk.usage != null) {
+                usage = {
+                    inputTokens: chunk.usage.prompt_tokens ?? 0,
+                    outputTokens: chunk.usage.completion_tokens ?? 0,
+                };
+            }
+        };
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let nl = buffer.indexOf('\n');
+            while (nl >= 0) {
+                const line = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                nl = buffer.indexOf('\n');
+                if (!line.startsWith('data:')) {
+                    for (const chunk of pending.splice(0))
+                        yield chunk;
+                    continue;
+                }
+                const payload = line.slice(5).trim();
+                if (payload !== "")
+                    handle(payload);
+                for (const chunk of pending.splice(0))
+                    yield chunk;
+            }
+        }
+        closeText();
+        for (const chunk of pending.splice(0))
+            yield chunk;
+        for (const entry of [...tools.values()].sort((a, b) => a.index - b.index)) {
+            yield {
+                type: 'block-end',
+                index: entry.index,
+                block: { type: 'tool-call', id: entry.id, name: entry.name, arguments: entry.args },
+            };
+        }
+        if (usage != null)
+            yield { type: 'usage', usage };
+        yield { type: 'finish', reason: finishOf(undefined, sawToolCall) };
+    }
+}
+//# sourceMappingURL=adapter.js.map

package/dist/adapter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adapter.test.d.ts.map

package/dist/adapter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.test.d.ts","sourceRoot":"","sources":["../src/adapter.test.ts"],"names":[],"mappings":""}

package/dist/adapter.test.js

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { finishOf, GenkakuAdapter, toOpenAiMessages } from "./adapter.js";
+test('developer messages are dropped and tool results keep their call id', () => {
+    const options = {
+        provider: 'genkaku',
+        model: 'm',
+        messages: [
+            { role: 'developer', content: [] },
+            { role: 'user', content: [{ type: 'text', text: 'hi' }] },
+            { role: 'assistant', content: [{ type: 'tool-call', id: 'c1', name: 'read', arguments: '{}' }] },
+            { role: 'tool', toolCallId: 'c1', content: [{ type: 'text', text: 'ok' }] },
+        ],
+    };
+    const out = toOpenAiMessages(options);
+    assert.equal(out.length, 3);
+    assert.deepEqual(out[1], {
+        role: 'assistant',
+        content: '',
+        tool_calls: [{ id: 'c1', type: 'function', function: { name: 'read', arguments: '{}' } }],
+    });
+    assert.deepEqual(out[2], { role: 'tool', tool_call_id: 'c1', content: 'ok' });
+});
+test('a tool call finishes as tool-calls, not stop', () => {
+    assert.deepEqual(finishOf(null, true), { kind: 'tool-calls' });
+    assert.deepEqual(finishOf('length', false), { kind: 'max-tokens' });
+    assert.deepEqual(finishOf('stop', false), { kind: 'stop' });
+});
+//# sourceMappingURL=adapter.test.js.map

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * GenKaKu user plugin — buy inference from the network.
+ *
+ * Pinned to the consuming role. It opens escrow sessions, streams tokens back
+ * over libp2p, and settles per started minute.
+ *
+ * The other half of this package is the harness integration: a GenKaKu model
+ * provider whose route is the plugin's own local bridge. Registering it here
+ * rather than asking the user to hand-write a pi-ai route is what makes the
+ * network appear in the normal model selector, with a warning badge on models
+ * that cannot drive an agent loop.
+ */
+/** Provider route key; also the prefix users see in model lists. */
+export declare const PROVIDER = "genkaku";
+export declare const name: string, inject: readonly string[], Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+    mode: import("@deepseek-ai/schemastery").default<"user" | "localPlusSharing" | "workerDedicated", "user" | "localPlusSharing" | "workerDedicated", "volatile-defined">;
+    env: import("@deepseek-ai/schemastery").default<"base-sepolia" | "base", "base-sepolia" | "base", "defined">;
+    port: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
+    workers: import("@deepseek-ai/schemastery").default<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    settle: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    paywall: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    keyDir: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+    catalog: import("@deepseek-ai/schemastery").default<({
+        model?: string | null | undefined;
+        pricePerHour?: string | null | undefined;
+        city?: string | null | undefined;
+        creditScore?: number | null | undefined;
+        sessionsServed?: number | null | undefined;
+        maxConcurrent?: number | null | undefined;
+    } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+        model: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+        pricePerHour: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+        city: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        creditScore: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+        sessionsServed: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+        maxConcurrent: import("@deepseek-ai/schemastery").default<number, number, "plain">;
+    }>>[], "defined">;
+    listen: import("@deepseek-ai/schemastery").default<string[], string[], "defined">;
+    publishAddress: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    workerName: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+    spawnOllama: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    ollamaHost: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    mode: import("@deepseek-ai/schemastery").default<"user" | "localPlusSharing" | "workerDedicated", "user" | "localPlusSharing" | "workerDedicated", "volatile-defined">;
+    env: import("@deepseek-ai/schemastery").default<"base-sepolia" | "base", "base-sepolia" | "base", "defined">;
+    port: import("@deepseek-ai/schemastery").default<number, number, "volatile-defined">;
+    workers: import("@deepseek-ai/schemastery").default<NoInfer<string[]>, NoInfer<string[]>, "volatile-defined">;
+    settle: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    paywall: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    keyDir: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+    catalog: import("@deepseek-ai/schemastery").default<({
+        model?: string | null | undefined;
+        pricePerHour?: string | null | undefined;
+        city?: string | null | undefined;
+        creditScore?: number | null | undefined;
+        sessionsServed?: number | null | undefined;
+        maxConcurrent?: number | null | undefined;
+    } & import("@deepseek-ai/cosmokit").Dict)[], Schemastery.ObjectT<NoInfer<{
+        model: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+        pricePerHour: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+        city: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+        creditScore: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+        sessionsServed: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+        maxConcurrent: import("@deepseek-ai/schemastery").default<number, number, "plain">;
+    }>>[], "defined">;
+    listen: import("@deepseek-ai/schemastery").default<string[], string[], "defined">;
+    publishAddress: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    workerName: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+    spawnOllama: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+    ollamaHost: import("@deepseek-ai/schemastery").default<string, string, "defined">;
+}>>, "plain">, apply: (ctx: import("@deepseek-ai/cordis").Context, config: import("@genkaku/dsh-runtime").Config) => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,oEAAoE;AACpE,eAAO,MAAM,QAAQ,YAAY,CAAA;AAEjC,eAAO,MAAQ,IAAI,UAAE,MAAM,qBAAE,MAAM;;;;;;;;;aAyB4pL,CAAC;oBAAqD,CAAC;YAA6C,CAAC;mBAAoD,CAAC;sBAAuD,CAAC;qBAAsD,CAAC;;;;;;;;;;;;;;;;;;;;;;;aAAiwC,CAAC;oBAAqD,CAAC;YAA6C,CAAC;mBAAoD,CAAC;sBAAuD,CAAC;qBAAsD,CAAC;;;;;;;;;;;;;;eAzB76O,KAAK,8GAwBxC,CAAA"}

package/dist/index.js

@@ -0,0 +1,35 @@
+/**
+ * GenKaKu user plugin — buy inference from the network.
+ *
+ * Pinned to the consuming role. It opens escrow sessions, streams tokens back
+ * over libp2p, and settles per started minute.
+ *
+ * The other half of this package is the harness integration: a GenKaKu model
+ * provider whose route is the plugin's own local bridge. Registering it here
+ * rather than asking the user to hand-write a pi-ai route is what makes the
+ * network appear in the normal model selector, with a warning badge on models
+ * that cannot drive an agent loop.
+ */
+import { defineGenkakuPlugin } from '@genkaku/dsh-runtime';
+import { GenkakuAdapter } from "./adapter.js";
+/** Provider route key; also the prefix users see in model lists. */
+export const PROVIDER = 'genkaku';
+export const { name, inject, Config, apply } = defineGenkakuPlugin({
+    pluginName: 'genkaku-user',
+    settingsNs: 'genkaku-user',
+    role: 'user',
+    injectExtra: ['llm'],
+    onStarted: (ctx, config) => {
+        const log = ctx.logger('genkaku-user');
+        const baseUrl = () => `http://127.0.0.1:${config.port.get()}/v1`;
+        const adapter = new GenkakuAdapter({ baseUrl, log: line => log.info(line) });
+        ctx.effect(() => ctx.llm.registerAdapter([PROVIDER], adapter), 'genkaku-user: llm adapter');
+        ctx.effect(() => ctx.llm.registerConfigurableProviders([{
+                provider: PROVIDER,
+                displayName: 'GenKaKu Network',
+                settingsNs: 'genkaku-user',
+                settingsPath: [],
+            }]), 'genkaku-user: provider route');
+    },
+});
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@genkaku/dsh-user-plugin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Buy peer-to-peer inference from the GenKaKu network",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "dsh": {
+    "target": ">=0.2.2-rc.2"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-llm": "0.2.2-rc.1",
+    "@genkaku/protocol": "0.1.1",
+    "@genkaku/dsh-runtime": "0.1.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.1.0",
+    "@deepseek-ai/dsh-llm": "0.2.2-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.1.0",
+    "@deepseek-ai/dsh-settings": "0.2.2-rc.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mlaimail77/genkaku-plugin.git",
+    "directory": "packages/user"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "GenKaKu Labs",
+  "homepage": "https://staging.genkaku.app",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "p2p",
+    "libp2p",
+    "ollama",
+    "usdc",
+    "base"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsc -p tsconfig.json && node --test dist/*.test.js"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-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.