Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

plugins/example-typescript/wit/smith-plugin.wit

Raw
package smith:plugin@0.1.0;

/// Structured child invocation; caller identity, grants, and generation are host-owned.
interface composition {
    /// Resolve an exact qualified target under the running caller authority.
    invoke: func(target: string, arguments-json: string) -> result<string, string>;
}

interface tooling {
    record tool-declaration {
        name: string,
        description: string,
        input-schema-json: string,
    }

    record file-read {
        path: string,
        offset: u64,
        limit: u64,
        max-bytes: u64,
    }

    record file-content {
        text: string,
    }

    record file-write {
        path: string,
        content: string,
    }

    record file-edit {
        path: string,
        old-text: string,
        new-text: string,
    }

    record directory-query {
        path: string,
        pattern: option<string>,
    }

    record command-request {
        text: string,
        timeout-ms: u64,
    }

    /// Read a bounded file window inside the host-granted workspace root.
    read: func(request: file-read) -> result<file-content, string>;
    /// Atomically publish a file inside the host-granted workspace root.
    write: func(request: file-write) -> result<_, string>;
    /// Replace exactly one matching range inside the host-granted workspace root.
    edit: func(request: file-edit) -> result<_, string>;
    /// List one directory level inside the host-granted workspace root.
    list-directory: func(request: directory-query) -> result<list<string>, string>;
    /// Find matching descendants inside the host-granted workspace root.
    find: func(request: directory-query) -> result<list<string>, string>;
    /// Search matching lines inside the host-granted workspace root.
    grep: func(request: directory-query) -> result<list<string>, string>;
    /// Run a bounded command with the host-granted workspace as cwd.
    run-command: func(request: command-request) -> result<string, string>;
}

interface net-scope {
    record header {
        name: string,
        value: string,
    }

    record request-options {
        timeout-ms: u64,
        response-bytes-max: u64,
    }

    record http-request {
        destination: string,
        method: string,
        headers: list<header>,
        body: list<u8>,
        options: request-options,
    }

    record http-response {
        status: u16,
        headers: list<header>,
        body: list<u8>,
    }

    /// Execute only against a host-authorized destination with explicit bounds.
    request: func(request: http-request) -> result<http-response, string>;
}

interface secret-proxy {
    /// Opaque host-issued secret identity; its plaintext never crosses WIT.
    record secret-ref {
        id: string,
    }

    record credential-exchange {
        source: secret-ref,
        audience: string,
        scopes: list<string>,
    }

    /// Declarative public-client policy, compared with explicit host authority.
    enum login-flow {
        dynamic-oidc,
        fixed-client-pkce-opaque,
        google-installed-pkce,
    }

    record login-policy {
        flow: login-flow,
        connection-id: string,
        token-origin: string,
        issuer: string,
        audience: string,
        initial-client: string,
        issued-prefix: string,
        authorization-path: string,
        token-path: string,
        agent-name: string,
        scopes: list<string>,
        required-scopes: list<string>,
    }

    /// Metadata-only profile handle; no token crosses this interface.
    record profile-ref {
        id: string,
    }

    /// Bounded authorization operation failures, never engine diagnostics or credentials.
    variant authorization-fault {
        capability,
        authority,
        cancelled,
        deadline-exceeded,
        network,
        exchange-uncertain,
        rejected,
        storage,
    }

    /// Host owns callback, presentation, entropy, crypto, HTTP, and atomic storage.
    authorize: func(policy: login-policy) -> result<profile-ref, authorization-fault>;

    /// End the selected renewable session and always clear local tokens; bool confirms remote revocation.
    end-session: func(profile: profile-ref) -> result<bool, authorization-fault>;

    /// Renew the explicitly selected profile after durable provider dispatch admission.
    renew: func(profile: profile-ref, policy: login-policy) -> result<secret-ref, authorization-fault>;

    /// Ask the host to derive another opaque credential reference.
    exchange: func(request: credential-exchange) -> result<secret-ref, string>;
}

interface log {
    /// Record one bounded diagnostic message for this invocation.
    write: func(level: string, message: string) -> result<_, string>;
}

interface provider {
    variant settings-provenance {
        built-in,
        user,
        trusted-project,
        explicit,
    }

    record provider-settings {
        include-usage: bool,
        /// Host-selected billing mode; codecs must not infer it from credentials.
        subscription: bool,
        provenance: settings-provenance,
    }

    record model-capabilities {
        output-tokens-max: u64,
        tool-use: bool,
        thinking: bool,
    }

    record catalog-model {
        id: string,
        capabilities: model-capabilities,
    }

    variant catalog-source {
        bundled,
        cache,
        models-dev,
    }

    record catalog-snapshot {
        generation: u64,
        source: catalog-source,
        models: list<catalog-model>,
    }

    variant message-role {
        system,
        user,
        assistant,
        tool,
    }

    record tool-use {
        name: string,
        input-json: string,
        call-id: string,
    }

    record tool-result {
        call-id: string,
        name: string,
        output: string,
    }

    variant message-block {
        text(string),
        thinking(string),
        tool-use(tool-use),
        tool-result(tool-result),
    }

    record provider-message {
        role: message-role,
        blocks: list<message-block>,
    }

    record provider-tool {
        name: string,
        description: string,
        input-schema-json: string,
    }

    /// Host-bound noncredential Google subscription context.
    record code-assist-context {
        project: string,
        user-prompt-id: string,
    }

    record provider-request {
        code-assist: option<code-assist-context>,
        messages: list<provider-message>,
        tools: list<provider-tool>,
        output-tokens-max: option<u64>,
    }

    record request-template {
        url: string,
        authorization: string,
        body: string,
    }

    record usage {
        input-tokens: u64,
        output-tokens: u64,
        input-cache-hit-tokens: u64,
        input-cache-write-tokens: u64,
    }

    variant stop-reason {
        end-turn,
        tool-use,
        limit,
        abort,
        stop-sequence,
        refusal,
        content-filter,
    }

    variant stream-event {
        text(string),
        thinking(string),
        tool-use(tool-use),
        stop(tuple<stop-reason, option<usage>>),
    }

    record decode-step {
        state: list<u8>,
        events: list<stream-event>,
    }

    /// Declare codec-owned default settings during registration.
    declare-settings: func() -> provider-settings;

    /// Validate immutable effective codec configuration.
    validate-settings: func(settings: provider-settings) -> result<provider-settings, string>;

    /// Purely map one provider-neutral request plus immutable host snapshots to a request template.
    build-request: func(model: string, request: provider-request, settings: provider-settings, catalog: catalog-snapshot) -> result<request-template, string>;

    /// Decode one bounded raw response chunk with explicit host-owned codec state.
    decode-response: func(state: list<u8>, chunk: list<u8>, finished: bool) -> result<decode-step, string>;
}

interface registration {
    variant protocol-binding {
        openai-compatible,
        anthropic-messages,
        google-gemini,
    }

    record credential-source {
        id: string,
    }

    record provider-contribution {
        id: string,
        protocol: protocol-binding,
        credential-source-id: string,
    }

    record model-contribution {
        id: string,
        provider-id: string,
    }

    record registrations {
        credential-sources: list<credential-source>,
        providers: list<provider-contribution>,
        models: list<model-contribution>,
    }

    /// Static declaration pass with no operational effects.
    declare: func() -> registrations;
}

interface plugin {
    use tooling.{tool-declaration};

    /// Static declaration pass: runs at instantiation, before publication,
    /// and may not perform host effects.
    declare-tools: func() -> list<tool-declaration>;

    /// Invoke one declared tool by name; input and output are canonical JSON.
    invoke: func(name: string, input-json: string) -> result<string, string>;
}

/// Optional major-versioned renewable module; only credential providers export it.
interface credential-source-v1 {
    use secret-proxy.{profile-ref, secret-ref, authorization-fault};
    resource credential-source {
        constructor(profile: profile-ref, fixture-issuer: option<string>, connection-id: string);
        renew: func() -> result<secret-ref, authorization-fault>;
    }
}

/// Optional protocol-specific binding; absence leaves legacy protocol exports unchanged.
interface protocol-openai-responses-v1 {
    /// Static major-versioned credential-source dependency, never an operational effect.
    credential-source: func() -> string;
}

world responses-world {
    include plugin-world;
    export protocol-openai-responses-v1;
}

world oauth-world {
    include plugin-world;
    export credential-source-v1;
}

world plugin-world {
    import composition;
    import tooling;
    import net-scope;
    import secret-proxy;
    import log;
    export plugin;
    export provider;
    export registration;
}