objectiveai-cocoindex 2.0.5__py3-none-any.whl

objectiveai_cocoindex/__init__.py

@@ -0,0 +1,37 @@
+"""ObjectiveAI integration for `cocoindex <https://github.com/cocoindex-io/cocoindex>`_.
+
+Exposes a single ``Function`` class that runs ObjectiveAI function executions
+as memoized cocoindex processing components. Memo key combines the bound
+``(function, profile, strategy)`` triple with the per-call ``input``.
+
+The ``client`` is intentionally excluded from the memo key — two
+``Function`` instances over the same triple with different clients share
+cache entries. This makes the library safe to drop into pipelines without
+worrying about client identity.
+"""
+
+from __future__ import annotations
+
+from objectiveai_cocoindex._client import set_default_client
+from objectiveai_cocoindex._errors import ObjectiveAIExecutionError
+from objectiveai_cocoindex._function import Function
+from objectiveai_cocoindex._sources import (
+    FunctionSource,
+    InlineFunction,
+    InlineProfile,
+    ProfileSource,
+    RemoteFunction,
+    RemoteProfile,
+)
+
+__all__ = [
+    "Function",
+    "set_default_client",
+    "FunctionSource",
+    "ProfileSource",
+    "RemoteFunction",
+    "InlineFunction",
+    "RemoteProfile",
+    "InlineProfile",
+    "ObjectiveAIExecutionError",
+]

objectiveai_cocoindex/_client.py

@@ -0,0 +1,33 @@
+"""Module-default ObjectiveAI client.
+
+Used by `Function` instances constructed without an explicit ``client``.
+Constructed lazily so importing this module doesn't require auth env vars.
+"""
+
+from __future__ import annotations
+
+from objectiveai_sdk.client import ObjectiveAI
+
+_default_instance: ObjectiveAI | None = None
+
+
+def set_default_client(client: ObjectiveAI | None) -> None:
+    """Set (or clear) the process-wide default ``ObjectiveAI`` client.
+
+    ``Function`` instances constructed without an explicit ``client``
+    will use this default. If unset, a fresh ``ObjectiveAI()`` is
+    constructed lazily on first use (reads ``OBJECTIVEAI_AUTHORIZATION``
+    and friends from the environment via ``ObjectiveAI()``'s own
+    constructor defaults).
+    """
+    global _default_instance
+    _default_instance = client
+
+
+def resolve_client() -> ObjectiveAI:
+    """Return the current default client, constructing one from env if
+    none has been set."""
+    global _default_instance
+    if _default_instance is None:
+        _default_instance = ObjectiveAI()
+    return _default_instance

objectiveai_cocoindex/_errors.py

@@ -0,0 +1,11 @@
+"""Errors raised by objectiveai-cocoindex wrappers."""
+
+from __future__ import annotations
+
+
+class ObjectiveAIExecutionError(RuntimeError):
+    """Raised when a function execution returns an error output (TaskOutputErr)."""
+
+    def __init__(self, payload: object) -> None:
+        super().__init__(f"ObjectiveAI execution error: {payload!r}")
+        self.payload = payload

objectiveai_cocoindex/_function.py

@@ -0,0 +1,91 @@
+"""Single-class wrapper that runs an ObjectiveAI function execution as a
+memoized cocoindex processing component.
+
+Bind the (function, profile, strategy) triple at construction; call with
+per-execution ``input``. Memo key combines all four. The optional
+``client`` is intentionally excluded from the memo key — two ``Function``
+instances over the same triple but with different clients share cache
+entries.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import cocoindex as coco
+from objectiveai_sdk.client import ObjectiveAI
+from objectiveai_sdk.functions.executions.http import create_function_execution
+from objectiveai_sdk.functions.executions.request import FunctionExecutionCreateParams
+from objectiveai_sdk.functions.executions.request.strategy import Strategy
+from objectiveai_sdk.functions.executions.response.unary import FunctionExecution
+
+from objectiveai_cocoindex._client import resolve_client
+from objectiveai_cocoindex._sources import FunctionSource, ProfileSource
+
+
+class Function:
+    """An ObjectiveAI function bound to a (function, profile, strategy)
+    triple, callable as a memoized cocoindex processing component.
+
+    Memo key combines the three constructor args + the per-call ``input``.
+    The optional ``client`` is intentionally excluded — two ``Function``
+    instances over the same triple with different clients share cache
+    entries.
+
+    Example::
+
+        import objectiveai_cocoindex as oai_coco
+
+        scorer = oai_coco.Function(
+            function=oai_coco.RemoteFunction.github(
+                owner="ObjectiveAI", repository="example-quality", commit="abc"
+            ),
+            profile=oai_coco.RemoteProfile.github(
+                owner="ObjectiveAI", repository="example-quality", commit="abc"
+            ),
+        )
+
+        execution = await scorer({"text": "hello"})
+        out = execution.output.output.root
+        # out is one of TaskOutputScalar | TaskOutputVector |
+        #               TaskOutputVectors | TaskOutputErr
+    """
+
+    __slots__ = ("_function", "_profile", "_strategy", "_client")
+
+    def __init__(
+        self,
+        function: FunctionSource,
+        profile: ProfileSource,
+        strategy: Strategy | None = None,
+        *,
+        client: ObjectiveAI | None = None,
+    ) -> None:
+        self._function = function
+        self._profile = profile
+        self._strategy = strategy
+        self._client = client
+
+    def __coco_memo_key__(self) -> object:
+        # Excludes self._client by design — clients should not invalidate
+        # cache entries.
+        return (
+            "objectiveai_cocoindex.Function",
+            self._function.__coco_memo_key__(),
+            self._profile.__coco_memo_key__(),
+            self._strategy.model_dump() if self._strategy is not None else None,
+        )
+
+    @coco.fn(memo=True, logic_tracking="self")
+    async def __call__(self, input: Any) -> FunctionExecution:
+        client = self._client if self._client is not None else resolve_client()
+        params = FunctionExecutionCreateParams(
+            function=self._function.to_function_field(),
+            profile=self._profile.to_profile_field(),
+            strategy=self._strategy,
+            input=input,
+        )
+        result = await create_function_execution(client, params)
+        if isinstance(result, FunctionExecution):
+            return result
+        return FunctionExecution.model_validate(result)

objectiveai_cocoindex/_sources.py

@@ -0,0 +1,243 @@
+"""ADTs for ObjectiveAI function and profile sources.
+
+A ``Function`` (the executor) takes one ``FunctionSource`` and one
+``ProfileSource`` at construction. Each source knows how to:
+
+  - translate itself into the request-field shape expected by
+    ``FunctionExecutionCreateParams``;
+  - return a stable ``__coco_memo_key__`` so cocoindex's memoization
+    fingerprint changes whenever the underlying ref/body changes.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from objectiveai_sdk.functions.full_inline_function import FullInlineFunction
+from objectiveai_sdk.functions.full_inline_function_or_remote_commit_optional import (
+    FullInlineFunctionOrRemoteCommitOptional,
+    FullInlineFunctionOrRemoteCommitOptionalInline,
+    FullInlineFunctionOrRemoteCommitOptionalRemote,
+)
+from objectiveai_sdk.functions.inline_profile import InlineProfile as InlineProfileBody
+from objectiveai_sdk.functions.inline_profile_or_remote_commit_optional import (
+    InlineProfileOrRemoteCommitOptional,
+    InlineProfileOrRemoteCommitOptionalInline,
+    InlineProfileOrRemoteCommitOptionalRemote,
+)
+from objectiveai_sdk.remote_path_commit_optional import (
+    RemotePathCommitOptional,
+    RemotePathCommitOptionalFilesystem,
+    RemotePathCommitOptionalGithub,
+    RemotePathCommitOptionalMock,
+)
+
+
+@runtime_checkable
+class FunctionSource(Protocol):
+    """Either an inline function body or a remote function reference."""
+
+    def to_function_field(self) -> FullInlineFunctionOrRemoteCommitOptional: ...
+    def __coco_memo_key__(self) -> object: ...
+
+
+@runtime_checkable
+class ProfileSource(Protocol):
+    """Either an inline profile body or a remote profile reference."""
+
+    def to_profile_field(self) -> InlineProfileOrRemoteCommitOptional: ...
+    def __coco_memo_key__(self) -> object: ...
+
+
+# ---------------------------------------------------------------------------
+# Remote sources
+# ---------------------------------------------------------------------------
+
+
+class RemoteFunction:
+    """Reference to a remotely-hosted function (GitHub, filesystem, mock).
+
+    Use the ``github`` / ``filesystem`` / ``mock`` classmethods rather than
+    the bare constructor.
+    """
+
+    __slots__ = ("_ref",)
+
+    def __init__(self, ref: RemotePathCommitOptional) -> None:
+        self._ref = ref
+
+    @classmethod
+    def github(
+        cls,
+        *,
+        owner: str,
+        repository: str,
+        commit: str | None = None,
+    ) -> RemoteFunction:
+        return cls(
+            RemotePathCommitOptional(
+                root=RemotePathCommitOptionalGithub(
+                    remote="github", owner=owner, repository=repository, commit=commit,
+                )
+            )
+        )
+
+    @classmethod
+    def filesystem(
+        cls,
+        *,
+        owner: str,
+        repository: str,
+        commit: str | None = None,
+    ) -> RemoteFunction:
+        return cls(
+            RemotePathCommitOptional(
+                root=RemotePathCommitOptionalFilesystem(
+                    remote="filesystem", owner=owner, repository=repository, commit=commit,
+                )
+            )
+        )
+
+    @classmethod
+    def mock(cls, *, name: str) -> RemoteFunction:
+        return cls(
+            RemotePathCommitOptional(
+                root=RemotePathCommitOptionalMock(remote="mock", name=name)
+            )
+        )
+
+    @property
+    def ref(self) -> RemotePathCommitOptional:
+        return self._ref
+
+    def to_function_field(self) -> FullInlineFunctionOrRemoteCommitOptional:
+        return FullInlineFunctionOrRemoteCommitOptional(
+            root=FullInlineFunctionOrRemoteCommitOptionalRemote(root=self._ref)
+        )
+
+    def __coco_memo_key__(self) -> object:
+        return ("objectiveai_cocoindex.RemoteFunction", self._ref.model_dump())
+
+    def __repr__(self) -> str:
+        return f"RemoteFunction({self._ref.root!r})"
+
+
+class RemoteProfile:
+    """Reference to a remotely-hosted profile (GitHub, filesystem, mock)."""
+
+    __slots__ = ("_ref",)
+
+    def __init__(self, ref: RemotePathCommitOptional) -> None:
+        self._ref = ref
+
+    @classmethod
+    def github(
+        cls,
+        *,
+        owner: str,
+        repository: str,
+        commit: str | None = None,
+    ) -> RemoteProfile:
+        return cls(
+            RemotePathCommitOptional(
+                root=RemotePathCommitOptionalGithub(
+                    remote="github", owner=owner, repository=repository, commit=commit,
+                )
+            )
+        )
+
+    @classmethod
+    def filesystem(
+        cls,
+        *,
+        owner: str,
+        repository: str,
+        commit: str | None = None,
+    ) -> RemoteProfile:
+        return cls(
+            RemotePathCommitOptional(
+                root=RemotePathCommitOptionalFilesystem(
+                    remote="filesystem", owner=owner, repository=repository, commit=commit,
+                )
+            )
+        )
+
+    @classmethod
+    def mock(cls, *, name: str) -> RemoteProfile:
+        return cls(
+            RemotePathCommitOptional(
+                root=RemotePathCommitOptionalMock(remote="mock", name=name)
+            )
+        )
+
+    @property
+    def ref(self) -> RemotePathCommitOptional:
+        return self._ref
+
+    def to_profile_field(self) -> InlineProfileOrRemoteCommitOptional:
+        return InlineProfileOrRemoteCommitOptional(
+            root=InlineProfileOrRemoteCommitOptionalRemote(root=self._ref)
+        )
+
+    def __coco_memo_key__(self) -> object:
+        return ("objectiveai_cocoindex.RemoteProfile", self._ref.model_dump())
+
+    def __repr__(self) -> str:
+        return f"RemoteProfile({self._ref.root!r})"
+
+
+# ---------------------------------------------------------------------------
+# Inline sources
+# ---------------------------------------------------------------------------
+
+
+class InlineFunction:
+    """Inline function definition. Accepts a ``FullInlineFunction`` body
+    constructed from ``objectiveai.functions``.
+    """
+
+    __slots__ = ("_body",)
+
+    def __init__(self, body: FullInlineFunction) -> None:
+        self._body = body
+
+    @property
+    def body(self) -> FullInlineFunction:
+        return self._body
+
+    def to_function_field(self) -> FullInlineFunctionOrRemoteCommitOptional:
+        return FullInlineFunctionOrRemoteCommitOptional(
+            root=FullInlineFunctionOrRemoteCommitOptionalInline(root=self._body)
+        )
+
+    def __coco_memo_key__(self) -> object:
+        return ("objectiveai_cocoindex.InlineFunction", self._body.model_dump())
+
+    def __repr__(self) -> str:
+        return f"InlineFunction({self._body!r})"
+
+
+class InlineProfile:
+    """Inline profile definition. Accepts an ``InlineProfile`` body
+    constructed from ``objectiveai.functions``.
+    """
+
+    __slots__ = ("_body",)
+
+    def __init__(self, body: InlineProfileBody) -> None:
+        self._body = body
+
+    @property
+    def body(self) -> InlineProfileBody:
+        return self._body
+
+    def to_profile_field(self) -> InlineProfileOrRemoteCommitOptional:
+        return InlineProfileOrRemoteCommitOptional(
+            root=InlineProfileOrRemoteCommitOptionalInline(root=self._body)
+        )
+
+    def __coco_memo_key__(self) -> object:
+        return ("objectiveai_cocoindex.InlineProfile", self._body.model_dump())
+
+    def __repr__(self) -> str:
+        return f"InlineProfile({self._body!r})"

objectiveai_cocoindex-2.0.5.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: objectiveai-cocoindex
+Version: 2.0.5
+Summary: ObjectiveAI integration for CocoIndex
+Project-URL: Homepage, https://objectiveai.dev
+Project-URL: Repository, https://github.com/ObjectiveAI/objectiveai
+Project-URL: Issues, https://github.com/ObjectiveAI/objectiveai/issues
+Author-email: ObjectiveAI <admin@objectiveai.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,cocoindex,indexing,llm,objectiveai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: cocoindex
+Requires-Dist: objectiveai-sdk==2.0.5
+Description-Content-Type: text/markdown
+
+# {ai} | ObjectiveAI
+
+[![npm version](https://img.shields.io/npm/v/objectiveai-sdk.svg)](https://www.npmjs.com/package/objectiveai-sdk)
+[![Crates.io](https://img.shields.io/crates/v/objectiveai-sdk.svg)](https://crates.io/crates/objectiveai-sdk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## The agentic collective judgment harness.
+
+Your agent doesn't have to decide alone. ObjectiveAI lets any agent call out to a **swarm** of models for collective judgment — routing decisions through recursive scoring trees that map arbitrary input into a vector of scores across every option. Functions are invented by agents, trained on data, and deployed as reusable decision infrastructure that gets better over time.
+
+[Website](https://objectiveai.dev) | [API](https://api.objectiveai.dev) | [Discord](https://discord.gg/gbNFHensby) | [npm](https://www.npmjs.com/package/objectiveai-sdk) | [crates.io](https://crates.io/crates/objectiveai-sdk) | [Built with ObjectiveAI](examples/README.md)
+
+## What this is
+
+An agent faces a choice. Instead of relying on a single model's judgment, it calls an ObjectiveAI Function — a recursive decision tree hosted as a JSON file. The Function fans out to a swarm of models, each with its own perspective. They vote. Their votes combine with learned weights. Out comes a vector of scores that sums to 1, one per option. The agent takes the highest-scoring option and moves on.
+
+The scoring pipeline itself is a composition of tasks — vector completions, nested functions, map operations — that can be arbitrarily deep. A Function can call other Functions. An agent can *invent* new Functions. The whole system is content-addressed, version-tracked, and trainable.
+
+```
+Agent has a decision
+    -> Calls ObjectiveAI Function
+        -> Function fans out to swarm of models
+            -> Each model votes across all options
+            -> Votes combine with learned weights
+        -> Returns scores: [0.42, 0.31, 0.18, 0.09]
+    -> Agent takes the best option
+```
+
+## Install
+
+### CLI
+
+Install the pre-built binary with one command:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/ObjectiveAI/objectiveai/main/install.sh | bash
+. "$HOME/.objectiveai/env"
+```
+
+Leaner, no-viewer build:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/ObjectiveAI/objectiveai/main/install.sh | bash -s -- --no-viewer
+. "$HOME/.objectiveai/env"
+```
+
+Sourcing `~/.objectiveai/env` puts `objectiveai` on `PATH` for the current shell. New shells pick it up automatically (the installer wires `~/.bashrc` / `~/.zshrc` to source the same file).
+
+Supported platforms: Linux x86_64, Linux aarch64 (Raspberry Pi 4+, Graviton), macOS x86_64, macOS aarch64 (Apple Silicon), Windows x86_64. The installer drops the binary at `~/.objectiveai/objectiveai`; the CLI self-updates on startup from [GitHub Releases](https://github.com/ObjectiveAI/objectiveai/releases).
+
+### SDK
+
+```bash
+npm install objectiveai-sdk
+```
+
+```toml
+[dependencies]
+objectiveai-sdk = "2.0.5"
+```
+
+## Core primitives
+
+### Agents
+
+An **Agent** is a fully-specified configuration of a single upstream model — model identity, prompt structure, decoding parameters, output mode, provider preferences. Content-addressed via XXHash3-128, so the same configuration always produces the same ID.
+
+Agents are stored as `agent.json` in Git repositories. Reference them by `owner/repo@commit` or define them inline.
+
+### Swarms
+
+A **Swarm** is a collection of Agents used together for collective judgment. Each agent can have its own personality, temperature, output mode, and count. Weights control each agent's influence on the final score.
+
+```json
+{
+  "description": "Balanced judgment panel",
+  "agents": [
+    {
+      "upstream": "openrouter",
+      "model": "openai/gpt-4o",
+      "output_mode": "json_schema",
+      "prefix_messages": [
+        { "role": "system", "content": "You are a rational skeptic. Ground every choice in logic." }
+      ],
+      "count": 2
+    },
+    {
+      "upstream": "openrouter",
+      "model": "anthropic/claude-sonnet-4-20250514",
+      "output_mode": "tool_call",
+      "suffix_messages": [
+        { "role": "system", "content": "You are an intuitive thinker. Trust your instincts." }
+      ],
+      "count": 1
+    }
+  ],
+  "weights": [0.6, 0.4]
+}
+```
+
+Swarms are stored as `swarm.json` in Git repositories — shareable, version-tracked, and reusable across Functions.
+
+### Vector Completions
+
+The core primitive. Give a swarm a prompt and a set of possible responses. Each agent votes for what it thinks is the best response. Votes combine with weights to produce a score vector that sums to 1.
+
+```
+Prompt: "Which approach best handles edge cases?"
+Responses: ["defensive coding", "fuzzing", "formal verification", "property testing"]
+
+-> Scores: [0.12, 0.28, 0.19, 0.41]
+```
+
+#### Probabilistic voting via logprobs
+
+LLMs are inherently probabilistic — the sampler makes the final discrete choice, destroying information. ObjectiveAI bypasses the sampler entirely using **logprobs** to capture each model's full preference distribution.
+
+If a model is 70% confident in option A and 30% in option B, we capture both signals rather than losing one to sampling. For large response sets exceeding logprobs limits, a prefix tree captures preferences in stages — the tree width matches the logprobs count (typically 20), enabling voting over hundreds of options while preserving probability information at each level.
+
+```
+Traditional: Model outputs "A" (loses the 30% signal for B)
+ObjectiveAI: Model vote = [0.70, 0.30, 0.00, 0.00] (full distribution preserved)
+```
+
+### Functions
+
+**Functions** are composable scoring pipelines. Data in, scores out. They're recursive decision trees that can contain vector completions, nested function calls, and map operations — arbitrarily composed.
+
+```
+Input -> [Task 1: Vector Completion] -> Score
+         [Task 2: Nested Function]   -> Score
+         [Task 3: Mapped Function]   -> Score
+      -> Weighted average -> Final score
+```
+
+Functions are hosted as `function.json` in Git repositories. Reference them by `owner/repo`:
+
+```
+objectiveai/sentiment-scorer
+```
+
+Functions produce either a **scalar** (single score in [0, 1]) or a **vector** (array of scores summing to 1). A scalar function that calls a vector function that calls another scalar function — all valid, all composable.
+
+### Profiles
+
+ObjectiveAI doesn't fine-tune models. It learns **weights**.
+
+Give it a dataset of inputs with expected outputs. ObjectiveAI executes repeatedly, computes loss, and adjusts the weights across your swarm to match. The result is a **Profile** — a learned weight configuration stored as `profile.json` that makes your Function's judgments converge on ground truth.
+
+### The resource graph
+
+Resources reference each other inline or remote:
+
+```
+agent.json  <-  swarm.json  <-  profile.json      function.json
+                 (agents)        (swarms+weights)   (tasks + input_schema)
+
+At execution: function.json + profile.json  ->  scores
+```
+
+Function and profile are independent files — execution takes both and combines them. All remote references use `(owner, repository, commit)` triples. Pin a commit SHA for reproducibility, or omit it to resolve to latest. The retrieval system resolves the entire graph, caching and deduplicating fetches along the way.
+
+## Function invention
+
+Agents can **invent** new Functions. The invention system takes a description of what you want to score, generates the input schema, designs the task tree, and produces a complete `function.json` — ready to deploy, train, and use. Recursive invention builds multi-level decision trees where each node is itself an invented Function.
+
+An agent that can invent its own judgment criteria, train them on data, and deploy them for future use. That's the loop.
+
+## Concepts
+
+| Concept | What it is |
+|---------|-----------|
+| **Agent** | A configured model with prompt, params, output mode. Content-addressed. `agent.json`. |
+| **Swarm** | A collection of Agents with weights. `swarm.json`. |
+| **Vector Completion** | Prompt + responses -> score vector that sums to 1. |
+| **Function** | Recursive scoring pipeline. Data in, scores out. `function.json`. |
+| **Profile** | Learned weights for a Function. Trained on data. `profile.json`. |
+| **Invention** | Agent-driven creation of new Functions. |
+
+## Repo structure
+
+```
+objectiveai/
+├── objectiveai-rs/             # Rust SDK (core crate: types, validation, compilation)
+├── objectiveai-api/            # API server (self-hostable)
+├── objectiveai-cli/            # CLI tool
+├── objectiveai-mcp-cli/        # MCP server exposing the CLI as an MCP tool
+├── objectiveai-mcp-filesystem/ # MCP filesystem server (Docker-injected into lab executions)
+├── objectiveai-mcp-proxy/      # MCP multiplexing proxy (sidecar of objectiveai-api)
+├── objectiveai-viewer/         # Local Tauri viewer (optional, embedded in CLI)
+├── objectiveai-web/            # Web interface (production)
+├── objectiveai-js/             # TypeScript SDK (npm: objectiveai)
+├── objectiveai-rs-wasm-js/     # WASM bindings for browser/Node.js
+├── objectiveai-py/             # Python package
+├── objectiveai-rs-pyo3/        # Rust crate behind objectiveai-py
+├── objectiveai-go/             # Go SDK
+├── objectiveai-dotnet/         # .NET SDK (in progress)
+├── objectiveai-rs-cffi/        # C FFI bindings (foundation for other langs)
+└── objectiveai-json-schema/    # Generated JSON Schema files
+```
+
+## Related
+
+### [ObjectiveAI-claude-code-1](https://github.com/ObjectiveAI-claude-code-1)
+
+An autonomous Claude Code agent that invents and publishes ObjectiveAI Functions without human intervention. Uses the Agent SDK to create, test, and deploy new scoring pipelines.
+
+## License
+
+MIT

objectiveai_cocoindex-2.0.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+objectiveai_cocoindex/__init__.py,sha256=i0cMHEtxDWBfKn_1E1w6DChvPOF2WyKXJFqrY96TIoE,1164
+objectiveai_cocoindex/_client.py,sha256=Ss86qNAN1ttaOlgLUCLxROnfK68DLIrhpIlGeQ_R5Ik,1094
+objectiveai_cocoindex/_errors.py,sha256=y4dEfpHIk99KPHUH5GnYs9o18K9Rw6jUrEIwaQrbk_k,375
+objectiveai_cocoindex/_function.py,sha256=O2ujm5CmK3NzCJYyGRFIRceP5aGfZ80yAwFF1J1DEyY,3442
+objectiveai_cocoindex/_sources.py,sha256=D9Lo5HcBmU7pp5Q2SvA2LnfMriklrr0i47YK7a1ydZg,7374
+objectiveai_cocoindex-2.0.5.dist-info/METADATA,sha256=a1P-1IRvotAOcsSlu9pjebf_2UKPfYNhFXzSDp4F58k,11007
+objectiveai_cocoindex-2.0.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+objectiveai_cocoindex-2.0.5.dist-info/licenses/LICENSE,sha256=QZu5oSTN6sZoulddS3v0oGpjXSpK24axI_lkmiOXR3A,1101
+objectiveai_cocoindex-2.0.5.dist-info/RECORD,,

objectiveai_cocoindex-2.0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

objectiveai_cocoindex-2.0.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Objective Artificial Intelligence, 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.